团体程序设计天梯赛-L2组

团体程序设计天梯赛-L2组

--------------------------------------------------------------------------------

题目传送门

团体程序设计天梯赛-L2组
--------------------------------------------------------------------------------
更多详见>>

OJ题解系列 目录导航帖
--------------------------------------------------------------------------------

序

这里是团体程序设计天梯赛-L2组
团体程序设计天梯赛，简称CCCC竞赛，从总体上来看，该竞赛难度不大，掌握基础的数据结构和算法便能够取得不错的分数，L1/L2/L3按照难度递增的顺序排列，其中L1是入门级的难度，类似于PAT乙级考试前3题，占100分；L2级加入了数据结构的元素，难度和PAT乙级后2题/PAT甲级前3题难度相当，占75分，L3级加入了算法进阶的内容，难度和PAT甲级最后一题/PAT顶级的难度一致，占75分。因此，练习的时候也可参考PAT专题部分，具体内容详见OJ题解系列 目录导航帖
接下来就是题解部分了，每道算法题都标注有对应的算法标签，对于那些易错、较难或是测试点比较特殊的题目会着重标注，本章推荐的题目有：

L2-012 关于堆的判断 (25 分)	堆 + 字符串
L2-013 红色警报 (25 分)	并查集
L2-014 列车调度 (25 分)	单调队列
L2-016 愿天下有情人都是失散多年的兄妹 (25 分) L2-030 冰岛人 (25 分)	并查集 + DFS/BFS
L2-018 多项式A除以B (25 分)	高精
L2-028 秀恩爱分得快 (25 分)	字符串 + 枚举
L2-034 口罩发放 (25 分)	大模拟 + 排序
L2-035 完全二叉树的层序遍历 (25 分)	树，二叉树 + 遍历

--------------------------------------------------------------------------------

L2-001 紧急救援 (25 分)

算法标签: 图论 + dijkstra + dfs
注意: dijkstra跑最短路，同时统计路径数，并更新点权最大值，是一道标准模板题，具体详见数据结构专题系列-图论

#include<bits/stdc++.h>
using namespace std;
int N,M,S,D;
const int maxn = 505;
int dp[maxn];
int num[maxn];
int pre[maxn];
int weight[maxn];
bool vis[maxn];
int a[maxn];
struct node{
	int v;
	int w;
};
node temp;
vector<node> G[maxn];
void Dijkstra(int S){
	memset(vis,0,sizeof(vis));
	memset(dp,0x3f,sizeof(dp));
	memset(num,0,sizeof(num));
	memset(weight,0,sizeof(weight));
	dp[S] = 0;
	num[S] = 1;
	weight[S] = a[S];
	priority_queue<pair<int,int> > q;
	q.push(make_pair(-dp[S],S));
	while(!q.empty()){
		pair<int,int> f = q.top();
		q.pop();
		int u = f.second;
		if(vis[u]){
			continue;
		}
		vis[u] = true;
		for(int i=0;i<G[u].size();i++){
			int v = G[u][i].v;
			int w = G[u][i].w;
			if(!vis[v]){
				if(dp[u]+w<dp[v]){
					dp[v] = dp[u] + w;
					num[v] = num[u];
					weight[v] = weight[u] + a[v];
					pre[v] = u;
					q.push(make_pair(-dp[v],v));
				}else if(dp[u]+w==dp[v]){
					num[v] += num[u];
					if(weight[u]+a[v]>weight[v]){
						weight[v] = weight[u] + a[v];
						pre[v] = u;
					}
				}
			}
		}
	}
}
vector<int> ans;
void Dfs(int u){
	if(u == S){
		ans.push_back(u);
		return;
	}
	Dfs(pre[u]);
	ans.push_back(u);
}
int main(){
	cin >> N >> M >> S >> D;	
	for(int i=0;i<N;i++){
		cin >> a[i];
	} 
	for(int i=1;i<=M;i++){
		int u,v,w;
		cin >> u >> v >> w;
		temp.v = v;
		temp.w = w;
		G[u].push_back(temp);
		temp.v = u;
		G[v].push_back(temp);
	}
	Dijkstra(S);
	cout << num[D] << " " << weight[D] << endl;
	Dfs(D);
	for(int i=0;i<ans.size();i++){
		if(i==0){
			printf("%d",ans[i]);
		}else{
			printf(" %d",ans[i]);
		} 
	}
	return 0;
} 

L2-002 链表去重 (25 分)

算法标签: 模拟 + 链表

#include<bits/stdc++.h>
using namespace std;
struct node{
	int value;
	int next;
};
const int maxn = 1e5+5;
node n[maxn];

int ori_add[maxn];
int ori_value[maxn];
int post_add[maxn];
int post_value[maxn];
int cnt1 = 0;
int cnt2 = 0;
set<int> s;

int main(){
	int start;
	int N;
	cin >> start >> N;
	for(int i=0;i<N;i++){
		int y;
		scanf("%d",&y);
		scanf("%d%d",&n[y].value,&n[y].next);
	}
	while(start!=-1){
		if(s.find(abs(n[start].value))!=s.end()){
			post_add[cnt2] = start;
			post_value[cnt2] = n[start].value;
			cnt2++; 
		}else{
			ori_add[cnt1] = start;
			ori_value[cnt1] = n[start].value;
			s.insert(abs(n[start].value));
			cnt1++;
		}
		start = n[start].next;
	} 
	for(int i=0;i<cnt1;i++){
		if(i!=cnt1-1){
			printf("%05d %d %05d\n",ori_add[i],ori_value[i],ori_add[i+1]);
		}else{
			printf("%05d %d -1\n",ori_add[i],ori_value[i]);
		}
	}
	for(int i=0;i<cnt2;i++){
		if(i!=cnt2-1){
			printf("%05d %d %05d\n",post_add[i],post_value[i],post_add[i+1]);
		}else{
			printf("%05d %d -1\n",post_add[i],post_value[i],post_add[i+1]);
		}
	}
	return 0;
} 

L2-003 月饼 (25 分)

算法标签: 完全背包的简单版

#include<bits/stdc++.h>
using namespace std;
int N,D;
int maxn = 1005;
typedef struct mooncake{
	double num;
	double price;
	double singleprice;
}mooncake;
bool cmp(mooncake m1,mooncake m2){
	return m1.singleprice > m2.singleprice;
}
int main(){
	cin >> N >> D;
	mooncake m[N];
	for(int i=0;i<N;i++){
		cin >> m[i].num;
	}
	for(int i=0;i<N;i++){
		cin >> m[i].price;
	}
	for(int i=0;i<N;i++){
		m[i].singleprice = (m[i].price * 1.0) /(m[i].num * 1.0);
	}
	
	sort(m,m+N,cmp);
	
	int site = 0;
	double totalprice = 0.0;
	
	while(D!=0){
		if(m[site].num <= D){
			D -= m[site].num;
			totalprice = totalprice + m[site].price;
		}else{
			totalprice = totalprice + m[site].singleprice * D;
			D = 0;
		}
		site++;
	}
	printf("%.2lf\n",totalprice);
	
	return 0;
}

L2-004 这是二叉搜索树吗？ (25 分)

算法标签: 树，二叉树 + 遍历
注意: 所谓的镜像树，其实就是指颠倒了左右子树的访问顺序，其它条件都不变，因此，本题实质上依然是考察建树+遍历

#include<bits/stdc++.h>
using namespace std;

vector<int> pre,preM,post,postM,origin;

int N; 
struct node{
	int data;
	node* lchild;
	node* rchild;
};

node* root = NULL;

void insert(node* &root,int x){
	if(root==NULL){
		node *Node = new node;
		Node->data = x;
		Node->lchild = NULL;
		Node->rchild = NULL;
		root = Node;
		return;
	}
	if(x<root->data){
		insert(root->lchild,x);
	}else{
		insert(root->rchild,x);
	}
}

int cnt = 0;

void PreOrder(node* root,vector<int> &pre){
	if(root==NULL){
		return;
	}
	pre.push_back(root->data);
	PreOrder(root->lchild,pre);
	PreOrder(root->rchild,pre);
}

void MirrorOrder(node *root,vector<int> &preM){
	if(root==NULL){
		return;
	}
	preM.push_back(root->data);
	MirrorOrder(root->rchild,preM);
	MirrorOrder(root->lchild,preM);
}

void PostOrder(node* root,vector<int> &post){
	if(root==NULL){
		return;
	}
	PostOrder(root->lchild,post);
	PostOrder(root->rchild,post);
	post.push_back(root->data);
}

void PostOrder1(node* root,vector<int> &postM){
	if(root==NULL){
		return;
	}
	PostOrder1(root->rchild,postM);
	PostOrder1(root->lchild,postM);
	postM.push_back(root->data);
}

int main(){
	cin >> N;
	for(int i=0;i<N;i++){
		int t;
		cin >> t;
		origin.push_back(t);
		insert(root,t);
	}
	
	PreOrder(root,pre);
	MirrorOrder(root,preM);
	
	if(pre==origin){
		printf("YES\n");
		PostOrder(root,post);
		for(int i=0;i<post.size();i++){
			if(i==0){
				printf("%d",post[i]);
			}else{
				printf(" %d",post[i]);
			}
		}
	}else if(preM==origin){
		printf("YES\n");
		PostOrder1(root,postM);
		for(int i=0;i<postM.size();i++){
			if(i==0){
				printf("%d",postM[i]);
			}else{
				printf(" %d",postM[i]);
			}
		}
	}else{
		printf("NO\n");
	}
	
	return 0;
}

L2-005 集合相似度 (25 分)

算法标签: 集合
注意: 本题考察的重点是集合，由于集合中的元素不能重复，因此，可用STL的set进行操作，每次查询输入两个集合的编号，我们采用枚举法判断集合的相似度，最后保留2位小数后输出

#include<bits/stdc++.h>
using namespace std;
set<int> a[55];
double query[60][60];
int main(){
    int N;
    scanf("%d",&N);
    for(int i=1;i<=N;i++){
        int M;
        scanf("%d",&M);
        for(int j=0;j<M;j++){
            int t;
            scanf("%d",&t);
            a[i].insert(t);
        }
    }
     
    int K;
    scanf("%d",&K);
    for(int i=0;i<K;i++){
        int g,h;
        scanf("%d%d",&g,&h);
        set<int>::iterator it1;
        set<int>::iterator it2;
        int Nc = 0;
        for(it1 = a[g].begin(),it2 = a[h].begin();it1!=a[g].end() && it2!=a[h].end();){
            if(*it1 == *it2){
                Nc++;
                it1++;
                it2++;
            }else if(*it1<*it2){
                it1++;
            }else{
                it2++;
            }
        }
        int Nn = a[g].size() + a[h].size() - Nc;
        double r = (Nc * 1.0) /(Nn * 1.0);
        printf("%.2lf%%\n",r*100.0);
    }
    return 0;
} 

L2-006 树的遍历 (25 分)

算法标签: 树，二叉树 + 遍历
注意: 首先输入中序遍历和后序遍历，建立一棵树，然后从根结点出发，进行层次遍历

#include<bits/stdc++.h>
using namespace std;

int post[35];
int in[35];
struct node{
	int data;
	node* lchild;
	node* rchild;
};
node* root = NULL;
node* newnode(int v){
	node* Node = new node;
	Node->data = v;
	Node->lchild = NULL;
	Node->rchild = NULL; 
	return Node;	
} 
node* Create(int inL,int inR,int postL,int postR){
	if(postL>postR){
		return NULL;
	}
	int d = post[postR];
	int k;
	for(int i=inL;i<=inR;i++){
		if(in[i]==d){
			k = i;
			break;
		}
	}
	int numleft = k-inL;
	node* Node = new node;
	Node->data = d; 
	Node->lchild = Create(inL,k-1,postL,postL+numleft-1);
	Node->rchild = Create(k+1,inR,postL+numleft,postR-1); 
	return Node;
}
queue<node*> q;
int n;
void Level(node* root){
	int T = n;
	q.push(root);
	while(!q.empty()){
		node* f = q.front();
		q.pop();
		if(T==1){
			printf("%d\n",f->data);
		}else{
			printf("%d ",f->data);
		}
		T--;
		if(f->lchild){
			q.push(f->lchild);
		}
		if(f->rchild){
			q.push(f->rchild);
		}
	}
}
int main(){
	cin >> n;
	for(int i=0;i<n;i++){
		cin >> post[i];
	}	
	for(int i=0;i<n;i++){
		cin >> in[i];
	}
	root = Create(0,n-1,0,n-1);
	Level(root);
	return 0;
}

L2-007 家庭房产 (25 分)

算法标签: 并查集 + 排序
注意: 本题极易与树、二叉树知识点混淆，该题的正确解法是并查集操作，合并parent与child，然后划定area

#include<bits/stdc++.h>
using namespace std;
struct person{
	int father;
	int mother;
	vector<int> child;
	int Mstate;
	int Area;
	bool f = false;
};
person p[10005];

int father[10005];

int findfather(int x){
	if(x == father[x]){
		return x;
	}else{
		int F = findfather(father[x]);
		father[x] = F;
		return F;	
	}
}

void Union(int a,int b){
	int fa = findfather(a);
	int fb = findfather(b);
	if(fa!=fb){
		if(fa<fb){
			father[fb] = fa;
		}else{
			father[fa] = fb;	
		}
	}
}

int num[10005];
double area[10005];
double state[10005];


struct ans{
	int ID;
	int number;
	double state;
	double area;
};
ans a[10005];

bool vis[10005];
bool hashT[10005];

int cnt = 0;

bool cmp(ans a1,ans a2){
	if(a1.area!=a2.area){
		return a1.area > a2.area;
	}else{
		return a1.ID < a2.ID;	
	}
}

int main(){
	for(int i=0;i<=9999;i++){
		father[i] = i;
	}
	int N;
	scanf("%d",&N);
	for(int i=0;i<N;i++){
		int id;
		scanf("%d",&id);
		hashT[id] = true;
		scanf("%d%d",&p[id].father,&p[id].mother);
		if(p[id].father!=-1){
			hashT[p[id].father] = true;
			Union(id,p[id].father);
		}
		if(p[id].mother!=-1){
			hashT[p[id].mother] = true;
			Union(id,p[id].mother);
		}
		int k;
		scanf("%d",&k);
		for(int j=0;j<k;j++){
			int cid;
			scanf("%d",&cid);
			p[id].child.push_back(cid);
			hashT[cid] = true;
			Union(id,cid);
		}
		scanf("%d%d",&p[id].Mstate,&p[id].Area);
		p[id].f = true;
	}
	
	
	for(int i=0;i<=9999;i++){
		int F = findfather(i);
		num[F]++;
		if(p[i].f){
			area[F] += p[i].Area;
			state[F] += p[i].Mstate;
		}
	}
	
	for(int i=0;i<=9999;i++){
		if(hashT[i]){
			int F = findfather(i);
			if(!vis[F] && num[F]){
				vis[F] = true;
				a[cnt].ID = i;
				a[cnt].number = num[F];
				a[cnt].state = state[F]/(num[F]*1.0);
				a[cnt].area = area[F]/(num[F]*1.0);
				cnt++;
			}	
		}
	}
	
	sort(a,a+cnt,cmp);
	printf("%d\n",cnt);
	for(int i=0;i<cnt;i++){
		printf("%04d %d %.3lf %.3lf\n",a[i].ID,a[i].number,a[i].state,a[i].area);
	}
	
	return 0;
} 

L2-008 最长对称子串 (25 分)

算法标签: DP
注意点: 动态规划求最长回文子串的题目，可得初始条件如下：
设$dp[i][j]$表示从第i个字符到第j个字符为回文串，那么
$dp[i][i]=1,L=1$
$dp[i][i+1]=1,s[i]==s[i+1],L=2$
$dp[i][j]=1,dp[i+1][j-1]=1且s[i]==s[j],L>=3$

#include<bits/stdc++.h>
using namespace std;
int dp[1005][1005];

int main(){
	string s;
	getline(cin,s);
	int len = s.size();
	int ans = 1;
	for(int i=0;i<len;i++){
		dp[i][i] = 1;
		if(i>=1 && s[i-1]==s[i]){
			dp[i-1][i] = 1;
			ans = 2;
		}
	}
	
	for(int i=3;i<=len;i++){
		for(int j=0;j<len-i+1;j++){
			int k = j+i-1;
			if(s[k] == s[j] && dp[j+1][k-1]==1){
				dp[j][k] = 1;
				ans = i;
			}
		}
	}
	cout << ans << endl;
	return 0; 
}

L2-009 抢红包 (25 分)

算法标签: 排序

#include<bits/stdc++.h>
using namespace std;
struct node{
	double price = 0.0;
	int num = 0;
	int number;	
};
const int maxn = 1e4+5;
node stu[maxn];
bool cmp(node stu1,node stu2){
	if(fabs(stu1.price-stu2.price)>1e-3){
		return stu1.price>stu2.price;
	}else if(stu1.num!=stu2.num){
		return stu1.num>stu2.num;
	}else{
		return stu1.number<stu2.number;
	}
}
int main(){
	int N;
	scanf("%d",&N);
	for(int i=1;i<=N;i++){
		stu[i].number = i;
		int K;
		scanf("%d",&K);
		for(int j=1;j<=K;j++){
			int id,v;
			scanf("%d%d",&id,&v);
			stu[i].price -= (v/100.0);
			stu[id].price += (v/100.0);
			stu[id].num++;
		}
	}
	sort(stu+1,stu+N+1,cmp);
	for(int i=1;i<=N;i++){
		printf("%d %.2lf\n",stu[i].number,stu[i].price);
	}
	return 0;
}

L2-010 排座位 (25 分)

算法标签: 并查集

#include<bits/stdc++.h>
using namespace std;
int N,M,K;
int father[105];
int findfather(int x){
	if(x==father[x]){
		return x;
	}else{
		int F = findfather(father[x]);
		father[x] = F;
		return F;	
	}
}
void Union(int a,int b){
	int fA = findfather(a);
	int fB = findfather(b);
	if(fA!=fB){
		father[fA] = fB;
	}
}

set<int> s2[105];
int main(){
	scanf("%d%d%d",&N,&M,&K);
	for(int i=1;i<=N;i++){
		father[i] = i;
	}
	for(int i=1;i<=M;i++){
		int u,v,w;
		scanf("%d%d%d",&u,&v,&w);
		if(w==1){
			Union(u,v);
		}else{
			s2[u].insert(v);
			s2[v].insert(u);
		}
	}
	for(int i=1;i<=K;i++){
		int u,v;
		scanf("%d%d",&u,&v);
		int fu = findfather(u);
		int fv = findfather(v);
		if(fu==fv && s2[u].find(v)==s2[u].end()){
			printf("No problem\n");
		}else if(fu!=fv && s2[u].find(v)==s2[u].end()){
			printf("OK\n");
		}else{
			if(fu!=fv && s2[u].find(v)!=s2[u].end()){
				printf("No way\n");
			}else{
				printf("OK but...\n");
			}
		}
	}
	
	return 0;
}

L2-011 玩转二叉树 (25 分)

算法标签: 树，二叉树 + 遍历
注意点: 根据中序遍历和先序遍历建树，然后层序遍历即可

#include<bits/stdc++.h>
using namespace std;
int in[35];
int pre[35];

struct node{
	int data;
	node* lchild;
	node* rchild;
};

node* newnode(int v){
	node* Node = new node;
	Node->data = v;
	Node->lchild = NULL;
	Node->rchild = NULL;
	return Node;
}

node* Create(int preL,int preR,int inL,int inR){
	if(preL>preR){
		return NULL;
	}
	node* root = newnode(pre[preL]);
	int k;
	for(int i=inL;i<=inR;i++){
		if(pre[preL] == in[i]){
			k = i;
			break;
		}
	}
	int numleft = k-inL;
	root->lchild = Create(preL+1,preL+numleft,inL,inL+numleft-1);
	root->rchild = Create(preL+numleft+1,preR,inL+numleft+1,inR);
	return root;
}
void levelorder(node* root){
	queue<node*> q;
	q.push(root);
	bool f1 = true;
	while(!q.empty()){
		node* f = q.front();
		q.pop();
		if(f1){
			cout << f->data;
			f1 = false;
		}else{
			cout << " " << f->data;
		}
		if(f->rchild){
			q.push(f->rchild);
		}
		if(f->lchild){
			q.push(f->lchild);
		}
	} 
}
int main(){
	int n;
	cin >> n;
	for(int i=0;i<n;i++){
		cin >> in[i];
	}
	for(int i=0;i<n;i++){
		cin >> pre[i];
	}
	node* root = NULL;
	root = Create(0,n-1,0,n-1);
	levelorder(root);
	
	return 0;
} 

L2-012 关于堆的判断 (25 分)

算法标签: 堆 + 字符串
注意点: 本题考察堆的插入操作：
1.本题容易与Floyd建堆混淆，题目中明确要求逐个元素插入到堆中，因此，是采用自下而上的上滤算法建堆，而不是采用自下而上的下滤算法建堆
2.如何判断这四类操作
（1）根结点很显然，判断a[1]是否与输入的root相等
（2）判断兄弟结点，拥有共同的父节点，判断n1/2 == n2/2
（3）判断父节点，n2/2 == n1
（4）判断子节点，n1/2 == n2
3.字符串中数字的读入，这里有一个坑点，负数如-1003，需特判前面的负号[测试点1]/[测试点3]

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e4+5;
int a[maxn];
void downadjust(int N){
	while(N>=2){
		if(a[N]<a[N/2]){
			swap(a[N],a[N/2]);
		}else{
			break;
		}
		N/=2;
	}
}
int main(){
	int N,M;
	cin >> N >> M;
	for(int i=1;i<=N;i++){
		cin >> a[i];
		downadjust(i);
	}
	getchar();
	for(int i=1;i<=M;i++){
		string s;
		getline(cin,s);
		if(s.find("is the root")!=-1){
			int site = s.find(" is the root");
			int num = 0;
			if(s[0] == '-'){
				for(int i=1;i<site;i++){
					num = num*10 + s[i] - '0';
				}
				num = -num;
			}else{
				for(int i=0;i<site;i++){
					num = num*10 + s[i] - '0';
				}	
			}
			if(a[1] == num){
				printf("T\n");
			}else{
				printf("F\n");
			}
		}else if(s.find("are siblings")!=-1){
			int site1 = s.find(" and");
			int num1 = 0;
			if(s[0] == '-'){
				for(int i=1;i<site1;i++){
					num1 = num1*10 + s[i] - '0';
				}
				num1 = -num1;
			}else{
				for(int i=0;i<site1;i++){
					num1 = num1*10 + s[i] - '0';
				}	
			}
			int site2 = s.find("and ");
			int site3 = s.find(" are");
			int num2 = 0;
			if(s[site2+4] == '-'){
				for(int i=site2+5;i<site3;i++){
					num2 = num2*10 + s[i] - '0';
				}
				num2 = -num2;
			}else{
				for(int i=site2+4;i<site3;i++){
					num2 = num2*10 + s[i] - '0';
				}	
			}
			int ans1,ans2;
			for(int i=1;i<=N;i++){
				if(num1 == a[i]){
					ans1 = i;
					break;
				}
			}
			for(int i=1;i<=N;i++){
				if(num2 == a[i]){
					ans2 = i;
					break;
				}
			}
			if(ans1/2 == ans2/2){
				printf("T\n");
			}else{
				printf("F\n");
			}
		}else if(s.find("is the parent of")!=-1){
			int site1 = s.find(" is");
			int num1 = 0;
			if(s[0] == '-'){
				for(int i=1;i<site1;i++){
					num1 = num1*10 + s[i] - '0';
				}
				num1 = -num1;
			}else{
				for(int i=0;i<site1;i++){
					num1 = num1*10 + s[i] - '0';
				}	
			}
			int site2 = s.find("of ");
			int num2 = 0;
			if(s[site2+3] == '-'){
				for(int i=site2+4;i<s.size();i++){
					num2 = num2*10 + s[i] - '0';
				}
				num2 = -num2;
			}else{
				for(int i=site2+3;i<s.size();i++){
					num2 = num2*10 + s[i] - '0';
				}	
			}
			int ans1,ans2;
			for(int i=1;i<=N;i++){
				if(num1 == a[i]){
					ans1 = i;
					break;
				}
			}
			for(int i=1;i<=N;i++){
				if(num2 == a[i]){
					ans2 = i;
					break;
				}
			}
			if(ans2/2==ans1){
				printf("T\n");
			}else{
				printf("F\n");
			}
		}else{
			int site1 = s.find(" is");
			int num1 = 0;
			if(s[0] == '-'){
				for(int i=1;i<site1;i++){
					num1 = num1*10 + s[i] - '0';
				}
				num1 = -num1;
			}else{
				for(int i=0;i<site1;i++){
					num1 = num1*10 + s[i] - '0';
				}
			}
			int site2 = s.find("of ");
			int num2 = 0;
			if(s[site2+3] == '-'){
				for(int i=site2+4;i<s.size();i++){
					num2 = num2*10 + s[i] - '0';
				}
				num2 = -num2;
			}else{
				for(int i=site2+3;i<s.size();i++){
					num2 = num2*10 + s[i] - '0';
				}	
			}
			int ans1,ans2;
			for(int i=1;i<=N;i++){
				if(num1 == a[i]){
					ans1 = i;
					break;
				}
			}
			for(int i=1;i<=N;i++){
				if(num2 == a[i]){
					ans2 = i;
					break;
				}
			}
			if(ans1/2==ans2){
				printf("T\n"); 
			}else{
				printf("F\n");
			}
		}
	}
	
	return 0;
} 

L2-013 红色警报 (25 分)

算法标签: 并查集
注意点: 本题考察的算法是并查集，但考察的是并查集的一种变式：如何理解题目所给的条件（失去一个城市并不改变其他城市之间的连通性）
首先我们来分析一下这个条件：
（1）若失去一个城市之后。连通图数量减少了1：那么失去的城市本身就是一个连通分量，它并不影响其他城市的连通性
（2）若失去一个城市之后，连通图数量不变：此时意味着本来是若干个连通分量，删除结点后，仍然是若干个连通分量，这些连通分量中的城市互相可达，说明删除这个城市并不影响其他城市的连通性
（3）若失去一个城市之后，连通图数量增加了1：此时意味着多出来的连通分量必定是原连通分量裂开后形成的，此时破坏了其余城市之间的连通性，因此这种情况下会发出alert

#include<bits/stdc++.h>
using namespace std;
const int maxn = 505;
bool hashT[maxn];
vector<int> G[maxn];
int a[maxn];
int father[maxn];
vector<int> res;
int findfather(int x){
	if(x==father[x]){
		return x;
	}else{
		int F = findfather(father[x]);
		father[x] = F;
		return F;	
	}
}
void Union(int a,int b){
	int fA = findfather(a);
	int fB = findfather(b);
	if(fA!=fB){
		father[fA] = fB;
	}
}
int calcu(int N){
	set<int> s;
	for(int i=0;i<N;i++){
		father[i] = i;
	}
	for(int i=0;i<N;i++){
		if(!hashT[i]){
			for(int j=0;j<G[i].size();j++){
				int v = G[i][j];
				if(!hashT[v]){
					Union(i,v);
				}
			} 
		}
	}
	for(int i=0;i<N;i++){
		if(!hashT[i]){
			s.insert(findfather(i));
		}
	} 
	int ans = s.size();
	return ans; 
}
int main(){
	int N,M;
	cin >> N >> M;
	
	for(int i=1;i<=M;i++){
		int u,v;
		cin >> u >> v;
		G[u].push_back(v);
		G[v].push_back(u); 
	}
	int K;
	cin >> K;
	for(int i=1;i<=K;i++){
		cin >> a[i];
	} 
	int start = calcu(N);
	for(int i=1;i<=K;i++){
		hashT[a[i]] = true;
		int tmp = calcu(N);
		if(tmp<=start){
			printf("City %d is lost.\n",a[i]);
		}else{
			printf("Red Alert: City %d is lost!\n",a[i]);
		}
		start = tmp;
	}
	if(K==N){
		printf("Game Over.\n");
	}
	
	return 0;
} 

L2-014 列车调度 (25 分)

算法标签: 单调队列
注意点: 一道好题！这道题思维难度比较大，但是代码量相对较少
首先我们分析一下题目，题目中要求火车出站的序列是单调递减的，也就是说编号较大的火车应该停靠在站台的前端，而编号较小的火车应该停靠在站台的后端，等到编号大的火车出站之后，编号小的自然排在了队头，这样即可满足出站的要求
仔细回想一下所学过的数据结构，发现单调队列正好满足这个要求，队列中总是保存着较小的编号，因此第一种方法就形成了，建立若干个单调队列，每个队列记录最小的编号，然后每次新来的火车，通过二分查找，找到最小编号最接近的站台，排在其后面，并更新该单调队列的记录，此方法可行，但还有更好的方案
纵观上一个方法，尽管我们需要维护若干个单调队列，但是，单调队列无需保存所有火车的编号，而只需要保存其中序列最小的那个即可，因此，可把每个队列抽象成一个数，这个数代表了能够进站的火车最大编号，所有小于这个数的火车被允许进站，排在其位置之后，并更新编号，编号的变化具有单调性（递减），而二分查找可替换成平衡树上查找，因此，我们引入一个集合set，用lower_bound二分查找，用insert快速插入，效率最高！

#include<bits/stdc++.h>
using namespace std;
set<int> s;
int main(){
	int N;
	scanf("%d",&N);
	for(int i=1;i<=N;i++){
		int t;
		scanf("%d",&t);
		set<int>::iterator it;
		it = s.lower_bound(t);
		if(it!=s.end()){
			s.erase(it);
			s.insert(t);
		}else{
			s.insert(t);
		}
	}
	int ans = s.size();
	cout << ans << endl;
	return 0;
} 

L2-015 互评成绩 (25 分)

算法标签: 排序
注意点: 先对每个人的部分成绩进行排序，然后去掉最高分和最低分，取平均值计算，得到个人最终成绩，最后对所有人的成绩进行排序，输出前M个即可

#include<bits/stdc++.h>
using namespace std;
double ans[10005];
int a[15];
int main(){
	int N,K,M;
	scanf("%d%d%d",&N,&K,&M);
	for(int i=1;i<=N;i++){
		for(int j=1;j<=K;j++){
			scanf("%d",&a[j]);
		} 
		sort(a+1,a+1+K);
		double ave = 0.0;
		for(int j=2;j<=K-1;j++){
			ave += a[j];
		}
		ave /= (K-2);
		ans[i] = ave;
	}
	sort(ans+1,ans+1+N);
	for(int i=N-M+1;i<=N;i++){
		if(i!=N){
			printf("%.3lf ",ans[i]);
		}else{
			printf("%.3lf\n",ans[i]);
		}
	}
	return 0;
}

L2-016 愿天下有情人都是失散多年的兄妹 (25 分)

算法标签: 并查集 + BFS/DFS
注意点: 首先，考虑到这道题的数据结构不是一棵树，因为找不到公共的祖先源点（根结点不唯一，是森林），因此采用并查集将所有祖先关系都合并起来（祖先关系不同源的人无需判断5层）
接着，有K组输入（题目中未给出K的大小，实际测试结果来看，大约100组数据左右，因为若K很大，BFS/DFS都是超时的算法，需考虑倍增LCA），每组输入给出2个编号，首先判断2个编号的性别，如果一样，输出Never Mind，否则再判断是否同源，若不是，则输出Yes，若是，继续判断5代以内是否有交集，由于题目中说了，给的数据都是同辈份的，这里就省略了需将结点提升到同一层的步骤（倍增LCA），可直接将ID1编号用BFS算法遍历5个层次，把每个层次遍历过的结点都打上已访问的标签，再进行ID2编号，若在5个层次内访问到了已打过标签的结点，则输出No，否则输出Yes

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+5;
int hashT[maxn];
int father[maxn];
vector<int> G[maxn];
bool vis[maxn];

int findfather(int x){
	if(x==father[x]){
		return x;
	}else{
		int F = findfather(father[x]);
		father[x] = F;
		return F;	
	}
}
void Union(int a,int b){
	int fA = findfather(a);
	int fB = findfather(b);
	if(fA!=fB){
		father[fA] = fB;
	}
}
void BFS(int u){
	queue<pair<int,int> > q;
	q.push(make_pair(u,1));
	vis[u] = true;
	while(!q.empty()){
		pair<int,int> f = q.front();
		q.pop();
		int u = f.first;
		int layer = f.second;
		if(layer<5){
			for(int i=0;i<G[u].size();i++){
				int v = G[u][i];
				if(!vis[v]){
					vis[v] = true;
					q.push(make_pair(v,layer+1));
				}
			}
		}
	}
}
int Check(int u){
	queue<pair<int,int> > q;
	q.push(make_pair(u,1));
	vis[u] = true;
	while(!q.empty()){
		pair<int,int> f = q.front();
		q.pop(); 
		int u = f.first;
		int layer = f.second;
		if(layer<5){
			for(int i=0;i<G[u].size();i++){
				int v = G[u][i];
				if(!vis[v]){
					vis[v] = true;
					q.push(make_pair(v,layer+1));
				}else{
					return 0;
				} 
			}
		}
	}
	return 1;
} 
int main(){
	for(int i=0;i<maxn;i++){
		father[i] = i;
	}
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		int id;
		scanf("%d",&id);
		char sex;
		cin >> sex;
		if(sex == 'M'){
			hashT[id] = 1;
		}else{
			hashT[id] = 2;
		}
		int mid,fid;
		scanf("%d%d",&fid,&mid);
		if(fid!=-1){
			G[id].push_back(fid);
			Union(id,fid);
			hashT[fid] = 1;
		}
		if(mid!=-1){
			G[id].push_back(mid);
			Union(id,mid);
			hashT[mid] = 2;
		}
	}
	int K;
	scanf("%d",&K);
	for(int i=1;i<=K;i++){
		int id1,id2;
		scanf("%d%d",&id1,&id2);
		if(hashT[id1] == hashT[id2]){
			printf("Never Mind\n"); 
		}else{
			int f1 = findfather(id1);
			int f2 = findfather(id2);
			if(f1 == f2){
				memset(vis,0,sizeof(vis));
				BFS(id1);
				int f = Check(id2);
				if(f == 1){
					printf("Yes\n");
				}else{
					printf("No\n");
				}
			}else{
				printf("Yes\n");
			}	
		}
	}
	return 0;
}

L2-017 人以群分 (25 分)

算法标签: 排序
注意点: 先对输入的序列进行排序，然后划分前N/2个为内向型集合，后N-N/2个为外向型集合，两个集合之差即为Diff

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+5;
int a[maxn];
int main(){
	int N;
	scanf("%d",&N);
	for(int i=1;i<=N;i++){
		scanf("%d",&a[i]);
	}
	sort(a+1,a+N+1);
	int N1,N2;
	if(N%2){
		N1 = N/2 +1 ;
		N2 = N-N1;
	}else{
		N1 = N2 = N/2;
	}
	printf("Outgoing #: %d\n",N1);
	printf("Introverted #: %d\n",N2);
	int ans = 0;
	for(int i=N-N1+1;i<=N;i++){
		ans += a[i];
	}
	for(int i=1;i<=N2;i++){
		ans -= a[i];
	}
	printf("Diff = %d\n",ans);
	return 0;
}

L2-018 多项式A除以B (25 分)

算法标签: 高精
注意点: 本题的算法和高精除法一致，模拟竖式相除即可，坑点有如下几个：
（1）本题未标注数据范围，题目保证所有指数是各不相同的非负整数，所有系数是非零整数，所有整数在整型范围内。
这句话本身是有问题的，如果指数e无限大（int上界），无法存储多项式（空间溢出），如果系数无限大，每一轮乘除过后误差不断累积，最终会使得15位有效数字的double不再精确，当误差超过0.05时，那么也无法完成多项式相除的功能（输出结果错误）
事实上，本题的数据比较水，最大的数据指数<3000，项数<3000,因此，除法最多3000次就能完成，算法复杂度$O(n^2)$即可
（2）零多项式是一个特殊多项式，对应输出为0 0 0.0,这个条件必须特判，测试点1/3/4会出现商或者余数是零多项式的情况
（3）舍入是什么：题目中说，多项式其实有常数项-1/27，但因其舍入后为0.0，这个例子还不够特殊，我们看输出样例：
3 2 0.3 1 0.2 0 -1.0，即
$0.3x^2+0.2x-1.0$
我们用竖式除法计算得到，商是$\frac{1}{3}{x}^2+\frac{2}{9}x-\frac{26}{27}$
$-\frac{26}{27}=-0.96$，答案输出为-1.0，这里就解释的很清楚了，舍入指的是对于小数点后1位进行四舍五入，因此用%.1lf的截断肯定错误，那么如何舍入呢？这里采用的是先将其扩大10倍，取整，四舍五入后，再除以10，还原成小数，对应于下面的convert函数

#include<bits/stdc++.h>
using namespace std;
const int maxn = 3e3+5;
double a[maxn];
double b[maxn];
double c[maxn]; 
double convert(double s){
	s *= 10;
	int res = (round)(s);
	double ans = res*1.0/10.0;
	return ans;
}
int main(){
	int N;
	scanf("%d",&N);
	int max1 = -1;
	int max2 = -1;
	for(int i=1;i<=N;i++){
		int e,coff;
		scanf("%d%d",&e,&coff);
		a[e] = coff*1.0;
		max1 = max(max1,e);
	} 
	scanf("%d",&N);
	for(int i=1;i<=N;i++){
		int e,coff;
		scanf("%d%d",&e,&coff);
		b[e] = coff*1.0;
		max2 = max(max2,e);
	}
	for(int i=max1;i>=max2;i--){
		if(fabs(a[i])>1e-3){
			double t = a[i]/b[max2];
			c[i-max2] += t;
			for(int j=max2;j>=0;j--){
				if(fabs(b[j])>1e-3){
					a[i-max2+j] -= (t*b[j]);
				}
			}
		}
	}
	int ans1 = 0;
	for(int i=max1-max2;i>=0;i--){
		double t = convert(c[i]);
		if(fabs(t)>1e-2){
			ans1++;
		}
	}
	printf("%d",ans1);
	if(ans1){
		for(int i=max1-max2;i>=0;i--){
			double t = convert(c[i]);
			if(fabs(t)>1e-2){
				printf(" %d %.1lf",i,t);
			} 
		}	
	}else{
		printf(" 0 0.0");
	}
	
	printf("\n");
	int ans2 = 0;
	for(int i=max2-1;i>=0;i--){
		double t = convert(a[i]);
		if(fabs(t)>1e-2){
			ans2++;
		}
	}
	printf("%d",ans2);
	if(ans2){
		for(int i=max2-1;i>=0;i--){
			double t = convert(a[i]);
			if(fabs(t)>1e-2){
				printf(" %d %.1lf",i,t);
			}
		}	
	}else{
		printf(" 0 0.0");
	}
	
	return 0;
}

L2-019 悄悄关注 (25 分)

算法标签: 哈希
注意点: 先建立一个集合用于查询输入的名字，然后计算平均值，线性扫描并统计后按字典序排序输出

#include<bits/stdc++.h>
using namespace std;
set<string> s;
struct node{
	string name;
	int v;
};
node stu[10005];
string ans[10005];
int main(){
	int N;
	cin >> N;
	for(int i=1;i<=N;i++){
		string t;
		cin >> t;
		s.insert(t);
	}
	int M;
	cin >> M;
	double ave = 0.0;
	for(int i=1;i<=M;i++){
		cin >> stu[i].name >> stu[i].v;
		ave += stu[i].v;
	}
	ave /= M;

	int cnt = 0;
	for(int i=1;i<=M;i++){
		if(stu[i].v>ave && s.find(stu[i].name)==s.end()){
			ans[cnt++] = stu[i].name;
		}
	}
	sort(ans,ans+cnt);
	if(!cnt){
		cout << "Bing Mei You"  << endl;
	}else{
		for(int i=0;i<cnt;i++){
			cout << ans[i] << endl;
		}
	}
	return 0;
}

L2-020 功夫传人 (25 分)

算法标签: 树，二叉树 + 遍历
注意点: 本题考察树的层次遍历，需注意测试点1的特殊情况，即祖师爷也是得道者，初始化的功力应该加倍！

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+5;
vector<int> G[maxn];
int hashT[maxn];
bool vis[maxn];
int N;
double Z,r;
double ans = 0.0;
void levelorder(int S){
	queue<pair<int,double>> q;
	if(hashT[S]){
		q.push(make_pair(S,Z*hashT[S]));
	}else{
		q.push(make_pair(S,Z));
	}
	vis[S] = true;
	while(!q.empty()){
		pair<int,double> f = q.front();
		q.pop();
		int u = f.first;
		double value = f.second;
		if(hashT[u]){
			ans += value;
		}
		for(int i=0;i<G[u].size();i++){
			int v = G[u][i];
			if(!vis[v]){
				if(hashT[v]){
					double temp = (100.0-r)/100.0 * value;
					temp = 1.0*temp*hashT[v];
					q.push(make_pair(v,temp));
					vis[v] = true;
				}else{
					double temp = (100.0-r)/100.0 * value;
					q.push(make_pair(v,temp));
					vis[v] = true;
				}	
			}
		}
	}
	long long res = (long long)ans;
	cout << res << endl;
}
int main(){
	cin >> N >> Z >> r;
	for(int i=1;i<=N;i++){
		int K;
		cin >> K;
		if(K==0){
			int M;
			cin >> M;
			hashT[i-1] = M;
		}else{
			for(int j=1;j<=K;j++){
				int v;
				cin >> v;
				G[i-1].push_back(v);
			}
		}
	}
	
	levelorder(0);
	return 0;
}

L2-021 点赞狂魔 (25 分)

算法标签: 哈希 + 排序
注意点: 用哈希方法统计不同标签的个数，然后结构体排序输出结果

#include<bits/stdc++.h>
using namespace std;
struct node{
	string s;
	int sum = 0;
	double ave = 0.0;
};
node stu[105];
bool cmp(node stu1,node stu2){
	if(stu1.sum!=stu2.sum){
		return stu1.sum > stu2.sum;
	}else{
		return stu1.ave < stu2.ave;
	}
}
int main(){
	int N;
	cin >> N;
	for(int i=1;i<=N;i++){
		cin >> stu[i].s;
		int K;
		cin >> K;
		set<int> s;
		for(int j=1;j<=K;j++){
			int t;
			cin >> t;
			s.insert(t);
		}
		int cnt =  s.size();
		stu[i].sum = cnt;
		stu[i].ave = K*1.0/cnt;
	}
	sort(stu+1,stu+1+N,cmp);
	if(N<3){
		for(int i=1;i<=N;i++){
			if(i==1){
				cout << stu[i].s;
			}else{
				cout << " " << stu[i].s;
			}
		}
		for(int i=1;i<=3-N;i++){
			cout << " " << "-";
		}
	}else{
		for(int i=1;i<=3;i++){
			if(i==1){
				cout << stu[i].s; 
			}else{
				cout << " " << stu[i].s;
			}
		}	
	}
	
	return 0;
}

L2-022 重排链表 (25 分)

算法标签: 链表 + 模拟
注意点: 一道关于链表的模拟题，分奇偶交错排列即可，难度不大，注意测试点3，这种情况下给出N个结点，但可连接成链表的结点数少于N个，因此需重新统计真正的结点个数，然后再进行计算！

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+5;
int address[maxn];
int nex[maxn];
int value[maxn];
int ans_add[maxn];
int ans_next[maxn];
int ans_value[maxn];
int main(){
	int S;
	cin >> S;
	int N;
	cin >> N;
	for(int i=1;i<=N;i++){
		int add;
		cin >> add;
		cin >> value[add] >> nex[add];
	}
	int t = S;
	int NL = 0;
	while(t!=-1){
		NL++;
		t = nex[t];
	}
	int N0 = NL/2;
	int cnt = 1;
	t = S;
	while(t!=-1){
		if(cnt<=N0){
			ans_value[cnt*2] = value[t];
			ans_add[cnt*2] = t;
		}else{
			int temp = (cnt-N0);
			temp = temp*2-1;
			if(NL%2==0){
				temp = NL-temp;
			}else{
				temp = NL-temp+1;
			}
			ans_value[temp] = value[t];
			ans_add[temp] = t;
		}
		cnt++;
		t = nex[t];
	}
	for(int i=1;i<=NL-1;i++){
		ans_next[i] = ans_add[i+1];
	}
	ans_next[NL] = -1;
	for(int i=1;i<=NL-1;i++){
		printf("%05d %d %05d\n",ans_add[i],ans_value[i],ans_next[i]);
	}
	printf("%05d %d %d\n",ans_add[NL],ans_value[NL],-1);
	return 0;
}

L2-023 图着色问题 (25 分)

算法标签: 图论 + 染色
注意点: 图染色的判断问题，首先是要判断颜色的数目，题目要求用K种颜色进行染色，也就是说，必须使用K种颜色，大于或小于都是不允许的，然后用K种颜色染色，保证无向图中，任意一条边的两个结点都是不同的颜色，最后输出判断的结果

#include<bits/stdc++.h>
using namespace std;

vector<int> G[505];
int a[505];
int main(){
	int V,E,K;
	cin >> V >> E >> K;
	for(int i=1;i<=E;i++){
		int u,v;
		cin >> u >> v;
		G[u].push_back(v);
		G[v].push_back(u); 
	}
	int N;
	cin >> N;
	for(int i=1;i<=N;i++){
		for(int j=1;j<=V;j++){
			cin >> a[j];
		}
		bool f = false;
		set<int> s;
		for(int j=1;j<=V;j++){
			s.insert(a[j]);
		}
		if(s.size()!=K){
			printf("No\n");
		}else{
			for(int u=1;u<=V;u++){
				for(int j=0;j<G[u].size();j++){
					int v = G[u][j];
					if(a[u]!=a[v]){
						continue;
					}else{
						f = true;
						break;
					}
				}
				if(f){
					break;
				}
			}
			if(f){
				printf("No\n");
			}else{
				printf("Yes\n");
			}
		}
	}
	return 0;
} 

L2-024 部落 (25 分)

算法标签: 并查集
注意点: 并查集模板题，具体可参考数据结构专题系列-并查集篇

#include<bits/stdc++.h>
using namespace std;
const int maxn = 10005;
int father[maxn];
int a[maxn];
int findfather(int x){
	if(x==father[x]){
		return x;
	}else{
		int F = findfather(father[x]);
		father[x] = F;
		return F;	
	}
}
void Union(int a,int b){
	int fA = findfather(a);
	int fB = findfather(b);
	if(fA!=fB){
		father[fA] = fB;
	}
}
set<int> s;
int main(){
	int N;
	cin >> N;
	for(int i=1;i<=10000;i++){
		father[i] = i;
	}
	for(int i=1;i<=N;i++){
		int K;
		cin >> K;
		for(int j=1;j<=K;j++){
			cin >> a[j];
			s.insert(a[j]);
		}
		for(int j=2;j<=K;j++){
			Union(a[1],a[j]);
		}
	}
	set<int> s2;
	for(auto it=s.begin();it!=s.end();it++){
		int t = *it;
		s2.insert(findfather(t));
	}
	int ans1 = s.size();
	int ans2 = s2.size();
	cout << ans1 << " " << ans2 << endl;
	int Q;
	cin >> Q;
	for(int i=1;i<=Q;i++){
		int u,v;
		cin >> u >> v;
		int fx = findfather(u);
		int fy = findfather(v);
		if(fx!=fy){
			cout << "N" << endl;
		}else{
			cout << "Y" << endl;
		}
	}
	return 0;
} 

L2-025 分而治之 (25 分)

算法标签: 图论 + 枚举
注意点: 枚举每个未被占领的顶点，判断是否连通即可！此处的连通是指不与任何城市有边连通，即孤立的顶点

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e4+5;
bool hashT[maxn];
vector<int> G[maxn];
int main(){
	int N,M;
	cin >> N >> M;
	for(int i=1;i<=M;i++){
		int u,v;
		cin >> u >> v;
		G[u].push_back(v);
		G[v].push_back(u);
	}
	int K;
	cin >> K;
	for(int i=1;i<=K;i++){
		memset(hashT,0,sizeof(hashT));
		int NP;
		cin >> NP;
		for(int i=1;i<=NP;i++){
			int t;
			cin >> t;
			hashT[t] = true;
		}
		bool f = true;
		for(int i=1;i<=N;i++){
			if(hashT[i]){
				continue;
			}else{
				for(int j=0;j<G[i].size();j++){
					int v = G[i][j];
					if(!hashT[v]){
						f = false;
						break;
					}
				}
				if(!f){
					break;
				}
			}
		}
		if(f){
			cout << "YES" << endl;
		}else{
			cout << "NO" << endl;
		}
	}
		
	
	return 0;
}

L2-026 小字辈 (25 分)

算法标签: 树，二叉树 + 遍历
注意点: 本题考察树的层次遍历，求树中最深结点的深度，并输出最底层叶结点的值

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+5;
int layer[maxn];
bool vis[maxn];
vector<int> G[maxn];
void levelorder(int root){
	queue<int> q;
	vis[root] = true;
	q.push(root);
	while(!q.empty()){
		int f = q.front(); 
		q.pop();
		for(int i=0;i<G[f].size();i++){
			int v = G[f][i];
			if(!vis[v]){
				vis[v] = true;
				layer[v] = layer[f] + 1;
				q.push(v);
			}
		}
	}
}
int main(){
	int N;
	scanf("%d",&N);
	int root = 0;
	for(int i=1;i<=N;i++){
		int t;
		scanf("%d",&t);
		if(t==-1){
			root = i;
			layer[root] = 1;
		}else{
			G[t].push_back(i);
		}
	}
	levelorder(root);
	int maxm = -1;
	for(int i=1;i<=N;i++){
		maxm = max(maxm,layer[i]);
	}
	cout << maxm << endl;
	int cnt = 0;
	for(int i=1;i<=N;i++){
		if(layer[i] == maxm){
			if(!cnt){
				cout << i;
			}else{
				cout << " " << i;
			}
			cnt++;
		}
	}
	return 0;
} 

L2-027 名人堂与代金券 (25 分)

算法标签: 排序
注意点: 需注意输出排名前K名的成绩单，由于存在并列的可能性，因此输出不一定是K个人

#include<bits/stdc++.h>
using namespace std;
struct node{
	string s;
	int score;
	int rank;
};
const int maxn = 1e4+5;
node stu[maxn];
bool cmp(node stu1,node stu2){
	if(stu1.score!=stu2.score){
		return stu1.score>stu2.score;
	}else{
		return stu1.s < stu2.s;
	}
}
int main(){
	int N,G,K;
	cin >> N >> G >> K;
	int ans = 0;
	for(int i=1;i<=N;i++){
		cin >> stu[i].s >> stu[i].score;
		if(stu[i].score>=G){
			ans += 50;	
		}else if(stu[i].score>=60){
			ans += 20;
		} 
	}
	cout << ans << endl;
	sort(stu+1,stu+1+N,cmp);
	stu[1].rank = 1;
	for(int i=2;i<=N;i++){
		if(stu[i].score == stu[i-1].score){
			stu[i].rank = stu[i-1].rank;
		}else{
			stu[i].rank = i;
		}
	}
	for(int i=1;i<=N;i++){
		if(stu[i].rank<=K){
			cout << stu[i].rank << " " << stu[i].s << " " << stu[i].score << endl;
		}else{
			break;
		}
	}
	return 0;
}

L2-028 秀恩爱分得快 (25 分)

算法标签: 字符串 + 枚举
注意点: 做这道题之前，可以先看这道题：PAT甲级 1139 First Contact (30 分)，具体可从[OJ题解系列 目录导航帖]获得
本题难度比那道题略小，坑点数量也少一些，由于可能出现+0与-0元素，-代表女生，+代表男生，因此读入的时候，用字符串读入，再转换成整数，输出时也注意+0与-0的输出
此外，输出A和B的条件为：当且仅当与A最亲密的异性是B，与B最亲密的异性是A，若两者其一不满足，那么就分别输出A最亲密的和B最亲密的

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e3+5;
int hashT[maxn];
int a[maxn];
double G[maxn][maxn];
int main(){
	int N,M;
	scanf("%d%d",&N,&M);
	for(int i=1;i<=M;i++){
		int K;
		scanf("%d",&K);
		for(int j=1;j<=K;j++){
			char s[6];
			scanf("%s",s);
			int number = 0;
			if(s[0] == '-'){
				for(int i=1;i<strlen(s);i++){
					number = number*10 + s[i]-'0';
				}
				hashT[number] = 2;
			}else{
				for(int i=0;i<strlen(s);i++){
					number = number*10 + s[i] -'0';
				}
				hashT[number] = 1;
			}
			a[j] = number;
		}
		double T = 1.0/K;
		for(int j=1;j<=K-1;j++){
			for(int k=j+1;k<=K;k++){
				G[a[j]][a[k]] += T;
				G[a[k]][a[j]] += T;
			}
		}
	}
	string sA,sB;
	cin >> sA >> sB;
	int f1 = 0,f2 = 0;
	int A = 0,B = 0;
	if(sA[0]=='-'){
		f1 = 2;
		for(int i=1;i<sA.size();i++){
			A = A*10 + sA[i]-'0';
		}
	}else{
		f1 = 1;
		for(int i=0;i<sA.size();i++){
			A = A*10 + sA[i] - '0';
		}
	}
	if(sB[0]=='-'){
		f2 = 2;
		for(int i=1;i<sB.size();i++){
			B = B*10 + sB[i] - '0';
		}
	}else{
		f2 = 1;
		for(int i=0;i<sB.size();i++){
			B = B*10 + sB[i] - '0';
		}
	}
	
	double maxA = -1.0; 
	double maxB = -1.0;
	
	for(int i=0;i<N;i++){
		if(((f1==2 && hashT[i]==1) || (f1==1 && hashT[i]==2)) && G[A][i]>maxA){
			maxA = G[A][i];
		}
	}
	for(int i=0;i<N;i++){
		if(((f2==2 && hashT[i]==1) || (f2==1 && hashT[i]==2)) && G[B][i]>maxB){
			maxB = G[B][i];
		}
	}
	double ans = G[A][B];
	
	if((fabs(ans-maxA)<1e-5 && fabs(ans-maxB)<1e-5)){
		cout << sA << " " << sB << endl;
	}else{
		for(int i=0;i<N;i++){
			if((f1==2 && hashT[i]==1) && fabs(G[A][i]-maxA)<1e-4){
				if(A==0){
					printf("-0 %d\n",i);
				}else{
					printf("%d %d\n",-A,i);
				}
			}else if((f1==1 && hashT[i]==2) && fabs(G[A][i]-maxA)<1e-4){
				if(i==0){
					printf("%d -0\n",A);
				}else{
					printf("%d %d\n",A,-i);
				}	
			}
		}
		for(int i=0;i<N;i++){
			if((f2==2 && hashT[i]==1) && fabs(G[B][i]-maxB)<1e-4){
				if(B==0){
					printf("-0 %d\n",i);
				}else{
					printf("%d %d\n",-B,i);
				}
			}else if((f2==1 && hashT[i]==2) && fabs(G[B][i]-maxB)<1e-4){
				if(i==0){
					printf("%d -0\n",B);
				}else{
					printf("%d %d\n",B,-i);
				}
			}
		}
	}
	return 0;
}

L2-029 特立独行的幸福 (25 分)

算法标签: 数论 + 模拟
注意点: 按照题目所给的条件模拟即可
（1）注意进入无限循环的判断，当出现了重复元素后，就退出迭代
（2）注意判断数字的“独立性”，将每个数迭代后，到1结束之间的所有数，都用哈希表记录下，未被记录过的数字一定是满足“独立性”的

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e4+5;
int a[maxn];
bool hashT[maxn];
int ans[maxn];
int calcu(int N){
	int ans = 0;
	while(N){
		int u = N%10;
		ans += u*u;
		N /=10;
	}
	return ans;
}
bool isprime(int N){
	if(N<2){
		return 0;
	}
	for(int i=2;i<=sqrt(N);i++){
		if(N%i==0){
			return 0;
		}
	}
	return 1;
}
int main(){
	int A,B;
	cin >> A >> B;
	for(int i=A;i<=B;i++){
		int t = i;
		set<int> s;
		while(t!=1){
			t = calcu(t);
			if(s.find(t) != s.end()){
				break;
			}else{
				s.insert(t);
			}
		}
		if(t == 1){
			for(auto it=s.begin();it!=s.end();it++){
				int u = *it;
				hashT[u] = true;
			}
			ans[i] = s.size();
		}
	}
	int cnt = 0;
	for(int i=A;i<=B;i++){
		if(!hashT[i] && ans[i]){
			cnt++;
			if(isprime(i)){
				printf("%d %d\n",i,2*ans[i]);
			}else{
				printf("%d %d\n",i,ans[i]);
			}
		}
	}
	if(!cnt){
		cout << "SAD" << endl;
	} 
	
	return 0;
}

L2-030 冰岛人 (25 分)

算法标签: LCA + BFS/DFS
注意点: 一道很坑的题目！
本题存在很多细节以及理解上的误差（题面表述不清晰）：
（1）维京人后裔是可以通过姓的后缀判断其性别的，其他人则是在姓的后面加 m 表示男性、f 表示女性。这句话表明带有m/f的后缀既有可能是维京人的祖先，也有可能是不是维京人。
（2）题目保证给出的每个维京家族的起源人都是男性。这句话表明只有m可能是维京人的祖先，f则不是维京人，因此，m/f都没有上一代，在树上无需建立边，而其余情况需建立从child到parent的边（代码中vis数组记录无需建立边的情况，[测试点2]/[测试点4]）
（3）题目保证不存在两个人是同名的，这意味着用名做key进行哈希查找
（4）接下来看题面的输出条件：
对每一个查询，根据结果在一行内显示以下信息：
1.若两人为异性，且五代以内无公共祖先，则输出 Yes；
2.若两人为异性，但五代以内（不包括第五代）有公共祖先，则输出 No；
3.若两人为同性，则输出 Whatever；（这里直接判断性别即可，外层if条件判断）
4.若有一人不在名单内，则输出 NA。（任意一个名字哈希查找失败，外层if条件判断）
3、4条件容易判断，1、2条件表述模糊，题目还补充了这么一个条件：
所谓“五代以内无公共祖先”是指两人的公共祖先（如果存在的话）必须比任何一方的曾祖父辈分高。
也就是说，要先找到公共祖先，然后判断该公共祖先不在任一个人的五代以内，比方说，LCA比A高9层，比B高3层，还是在五代以内，应该输出No，此时，我们再回看条件1、2，发现有表述不严谨之处，所谓五代以内，是指层次较高的结点五代以内没有公共祖先，对于层次较低的结点，可以理解为N代内无公共祖先（不限制5层，[测试点3]/[测试点6]）

#include<bits/stdc++.h>
using namespace std;
map<string,int> mp1;
map<int,string> mp2;
map<string,int> sex;
const int maxn = 2e5+5;
string C1[maxn];
string C2[maxn];
bool vis[maxn];
vector<int> G[maxn];

int cnt = 0;
int check(int u1,int u2){
	vector<int> v1;
	v1.push_back(u1);
	vector<int> v2;
	v2.push_back(u2); 
	int t1 = G[u1].size();
	while(t1){
		v1.push_back(G[u1][0]);
		u1 = G[u1][0];
		t1 = G[u1].size();
	}
	int t2 = G[u2].size();
	while(t2){
		v2.push_back(G[u2][0]);
		u2 = G[u2][0];
		t2 = G[u2].size();
	}
	if(v1.back() == v2.back()){
		int size1 = v1.size();
		int size2 = v2.size();
		while(size1>0 && size2>0 && v1[size1-1] == v2[size2-1]){
			size1--;
			size2--;
		}
		size1++;
		size2++;
		if(size1>=5 && size2>=5){
			return 1;
		}else{
			return 0;
		}
	}else{
		return 1;
	}
}

int main(){
	int N;
	scanf("%d",&N);
	for(int i=1;i<=N;i++){
		string s2,s1;		//s2-name,s1-surname
		cin >> s2 >> s1;
		int len1 = s1.size();
		string first;
		if(mp1.find(s2)==mp1.end()){
			mp1[s2] = ++cnt;
			mp2[cnt] = s2;
		}
		if(s1[len1-1] == 'm'){
			first = s1.substr(0,len1-1);
			sex[s2] = 1;
			vis[mp1[s2]] = true;
		}else if(s1[len1-1] == 'f'){
			first = s1.substr(0,len1-1);
			sex[s2] = 2;
            vis[mp1[s2]] = true;
		}else if(s1.substr(len1-4) == "sson"){
			first = s1.substr(0,len1-4);
			sex[s2] = 1;
		}else if(s1.substr(len1-7) == "sdottir"){
			first = s1.substr(0,len1-7);
			sex[s2] = 2;
		}
		if(mp1.find(first)==mp1.end()){
			mp1[first] = ++cnt;
			mp2[cnt] = first;
		}
		C1[i] = s2;
		C2[i] = first;
	}
	for(int i=1;i<=N;i++){
		if(!vis[mp1[C1[i]]]){
			int u = mp1[C1[i]];
			int v = mp1[C2[i]];
			G[u].push_back(v);	
		}
	}
	
	int M;
	scanf("%d",&M);
	for(int i=1;i<=M;i++){
		string name1,surname1,name2,surname2;
		cin >> name1 >> surname1 >> name2 >> surname2;
		if(mp1.find(name1) == mp1.end() || mp1.find(name2) == mp1.end()){
			printf("NA\n");
		}else{
			int t1 = sex[name1];
			int t2 = sex[name2];
			if(t1 == t2){
				printf("Whatever\n");
			}else{
				int u1 = mp1[name1];
				int u2 = mp1[name2];
				int op = check(u1,u2);
				if(op){
					printf("Yes\n");
				}else{
					printf("No\n");
				}
			}
		}
	} 
	return 0;
}

L2-031 深入虎穴 (25 分)

算法标签: 树，二叉树 + 遍历
注意点: 本题考察的算法为求一棵树的最大深度，这里采用DFS方法记录

#include<bits/stdc++.h>
using namespace std;
int N;
const int maxn = 1e5+5;
vector<int> G[maxn];
bool hashT[maxn];
vector<int> temp;
int ans;
int maxm = -1;
void dfs(int root){
	temp.push_back(root);
	if(G[root].size()==0){
		int S = temp.size();
		if(S>maxm){
			maxm = S;
			ans = root;
		}
	}else{
		for(int i=0;i<G[root].size();i++){
			int v = G[root][i];
			dfs(v);
		}
	}
	temp.pop_back();
}
int main(){
	cin >> N;
	for(int i=1;i<=N;i++){
		int K;
		cin >> K;
		for(int j=0;j<K;j++){
			int t;
			cin >> t;
			G[i].push_back(t);
			hashT[t] = true;
		}
	}
	int root = -1;
	for(int i=1;i<=N;i++){
		if(!hashT[i]){
			root = i;
			break;
		}
	}
	dfs(root);
	cout << ans << endl;
	
	return 0;
}

L2-032 彩虹瓶 (25 分)

算法标签: 栈混洗
注意点: 本题考察的是栈结构，给你一个序列，并且限制栈的大小，要求判断该序列是否为栈混洗的序列
当入栈元素超过栈大小时，或者是栈内还存在元素（无法取出）时，都是不合法序列，输出NO，其余情况输出YES

#include<bits/stdc++.h>
using namespace std;
int a[1005];
int main(){
	int N,M,K;
	cin >> N >> M >> K;
	for(int i=1;i<=K;i++){
		for(int j=1;j<=N;j++){
			cin >> a[j];
		}
		stack<int> s;
		int cnt = 1;
		bool f = true;
		for(int j=1;j<=N;){
			if(a[j] == cnt){
				cnt++;
				j++;
			}else if(!s.empty() && cnt == s.top()){
				s.pop();
				cnt++;
			}else{
				s.push(a[j]);
				j++;
				if(s.size()>M){
					f = false;
					break;
				}
			}
		}
		
		while(!s.empty()){
			if(s.top() == cnt){
				cnt++;
				s.pop();
			}else{
				break;
			}
		}
		if(!s.empty()){
			f = false;
		}
		if(f){
			printf("YES\n");
		}else{
			printf("NO\n");
		}
	} 
	
	return 0;
}

L2-033 简单计算器 (25 分)

算法标签: 栈
注意点: 栈算法模板题，考察了栈的符号算术功能

#include<bits/stdc++.h>
using namespace std;
int a[1005];
stack<int> s1;	
stack<char> s2;
int main(){
	int N;
	cin >> N;
	for(int i=1;i<=N;i++){
		int t;
		cin >> t;
		s1.push(t);
	}
	for(int i=1;i<=N-1;i++){
		char ch;
		cin >> ch;
		s2.push(ch);
	}
	while(!s2.empty()){
		int n1 = s1.top();
		s1.pop();
		int n2 = s1.top();
		s1.pop();
		char ch = s2.top();
		s2.pop();
		if(ch == '+'){
			int ans = n2 + n1;
			s1.push(ans);
		}else if(ch == '-'){
			int ans = n2 - n1;
			s1.push(ans);
		}else if(ch == '*'){
			int ans = n2 * n1;
			s1.push(ans);
		}else{
			if(n1==0){
				printf("ERROR: %d/0",n2);
				exit(0);
			}else{
				int ans = n2 / n1;
				s1.push(ans);
			}
		}
	}
	cout << s1.top() << endl;
	return 0;
}

L2-034 口罩发放 (25 分)

算法标签: 大模拟 + 排序
注意点: 一道坑题！
由于题意不清，因此理解上可能会有各式各样的问题，首先，梳理一下题目中的各种词汇：
（1）申请信息——每一个数据块给出一天的申请信息、申请信息的每一条记录为申请记录
（2）发放信息——程序输出的发放记录，按照提交时间第一优先级，申请记录顺序第二优先级排序
（3）状况信息——顺序按照申请记录中出现的顺序确定，不重不漏（合法记录指ID号18位，且是数字）
纵观题目的各个条件，我们发现（2）是需要排序的，而（3）是不需要排序的。因此先处理（3），再处理（2）
要确保信息的不重复，则必须采用哈希算法，由于ID号的唯一性，因此用ID作为关键字，建立与name的映射
最后注意一点，ID号必须为18位，且都是数字（不是字符）！

#include<bits/stdc++.h>
using namespace std;
const int maxn = 3e4+5;
struct node{
	string name;
	string ID;
	int op;
	int h;
	int m;
	int Day;
	int number;
};
node stu[1005];

int hashT[maxn];
bool vis[maxn];
string ans[maxn];
int res = 0;

bool cmp(node stu1,node stu2){
	if(stu1.h!=stu2.h){
		return stu1.h < stu2.h;
	}else if(stu1.m!=stu2.m){
		return stu1.m < stu2.m;
	}else{
		return stu1.number < stu2.number;
	}
}

map<string,int> mp1;
map<int,string> mp2;
map<string,string> mp3;

int check(string s){
	for(int i=0;i<s.size();i++){
		if(s[i]>='0' && s[i]<='9'){
			continue;
		}else{
			return 0;
		}
	} 
	return 1;
}
int main(){
	int D,P;
	scanf("%d%d",&D,&P);
	int cnt = 0;
	for(int i=0;i<maxn;i++){
		hashT[i] = -100;
	}
	for(int i=1;i<=D;i++){
		int T,S;
		scanf("%d%d",&T,&S);
		for(int j=1;j<=T;j++){
			cin >> stu[j].name >> stu[j].ID >> stu[j].op;
			scanf("%d:%d",&stu[j].h,&stu[j].m);
			stu[j].Day = i;
			stu[j].number = j;
			int len = stu[j].ID.size();
			if(len==18 && check(stu[j].ID)){
				if(mp1.find(stu[j].ID) == mp1.end()){
					mp1[stu[j].ID] = ++cnt;
					mp2[cnt] = stu[j].ID;
					mp3[stu[j].ID] = stu[j].name;
				}
				int id = mp1[stu[j].ID];
				if(stu[j].op == 1 && !vis[id]){
					vis[id] = true;
					ans[res++] = stu[j].ID;
				}	
			}
		}
		sort(stu+1,stu+1+T,cmp);
		for(int j=1;j<=T;j++){
			int len = stu[j].ID.size();
			if(len==18 && check(stu[j].ID)){
				if(mp1.find(stu[j].ID) == mp1.end()){
					mp1[stu[j].ID] = ++cnt;
					mp2[cnt] = stu[j].ID;
					mp3[stu[j].ID] = stu[j].name;
				}
				int id = mp1[stu[j].ID];
				int D1 = hashT[id];
				if(stu[j].Day-D1>P && S>0){
					S--;
					hashT[id] = stu[j].Day;
					cout << stu[j].name << " " << stu[j].ID << endl;
				}
			}
		}
	}
	for(int i=0;i<res;i++){
		cout << mp3[ans[i]] << " " << ans[i] << endl;
	}
	return 0;
}

L2-035 完全二叉树的层序遍历 (25 分)

算法标签: 树，二叉树 + 遍历
注意点: 一道好题！这里给出了一种新的建树方式，后序遍历建树（完全二叉树），按序输出即为层次遍历的值

#include<bits/stdc++.h>
using namespace std;
int post[35];
int N;
void postorder(int root){
	if(root>N){
		return;
	} 
	postorder(root * 2);
	postorder(root * 2 + 1);
	cin >> post[root];
}
int main(){
	cin >> N;
	postorder(1);
	for(int i=1;i<=N;i++){
		if(i==1){
			cout << post[i];
		}else{
			cout << " " << post[i];
		}
	}
	
	return 0;
}

L2-036 网红点打卡攻略 (25 分)

算法标签: 图论 + 哈密尔顿环路
注意点: 本题考察哈密尔顿环路问题，首先需要判断哈密尔顿环路是否满足（路径连通，且访问每个顶点仅一次），满足条件则统计，并记录最短路径和当前的方案编号

#include<bits/stdc++.h>
using namespace std;
const int maxn = 205;
int G[205][205];
int a[205];
bool hashT[205];
int main(){
	memset(G,0x3f,sizeof(G));
	int N,M;
	cin >> N >> M;
	for(int i=1;i<=M;i++){
		int u,v,w;
		cin >> u >> v >> w;
		G[u][v] = G[v][u] = w;
	} 
	int K;
	cin >> K;
	int cnt = 0;
	int maxm = 0x3f3f3f3f;
	int site = -1;
	for(int i=1;i<=K;i++){
		memset(hashT,0,sizeof(hashT));
		memset(a,0,sizeof(a));
		int n;
		cin >> n;
		for(int j=1;j<=n;j++){
			cin >> a[j];
			hashT[a[j]] = 1;
		}
		if(n!=N){
			continue;
		}else{
			bool f = true;
			for(int i=1;i<=N;i++){
				if(hashT[i]){
					continue;
				}else{
					f = false;
					break;
				}
			}
			if(f){
				int ans = 0;
				bool f2 = true;
				for(int i=1;i<=N+1;i++){
					if(G[a[i-1]][a[i]]!=0x3f3f3f3f){
						ans += G[a[i-1]][a[i]];
					}else{
						f2 = false;
						break;
					}
				}
				if(f2){
					cnt++;
					if(ans<maxm){
						maxm = ans;
						site = i;
					}
				}
			}
		}
	}
	cout << cnt << endl;
	cout << site << " " << maxm << endl;
	return 0;
}

L2-037 包装机 (25 分)

算法标签: 模拟
注意点: 按照题目操作要求模拟包装机的过程，注意栈和队列的判空！

#include<bits/stdc++.h>
using namespace std;
queue<char> q[105];
stack<int> s;
string out = "";
int main(){
	int N,M,Smax;
	scanf("%d%d%d",&N,&M,&Smax);
	for(int i=1;i<=N;i++){
		for(int j=1;j<=M;j++){
			char t;
			cin >> t;
			q[i].push(t);
		}
	}
	int op;
	int cnt = 0;
	while(scanf("%d",&op) && op!=-1){
		if(op == 0){
			if(!s.empty()){
				char t = s.top();
				s.pop();
				out += string(1,t);
				cnt--;
			}
		}else{
			if(!q[op].empty()){
				char f = q[op].front();
				q[op].pop();
				if(cnt == Smax){
					char t = s.top();
					s.pop();
					out += string(1,t);
					s.push(f);
				}else{
					s.push(f);
					cnt++;
				}
			}
		}
	}
	cout << out << endl;
	return 0;
}

L2-038 病毒溯源 (25 分

算法标签: 树，二叉树 + DFS遍历
注意点: 首先找到根结点root（不是任何子结点的结点一定是根结点），然后从根结点开始执行DFS遍历，即可求出最大深度，输出字典序较小的结果即可

#include<bits/stdc++.h>
using namespace std;
int N;
const int maxn = 1e4+5;
vector<int> G[maxn];
bool hashT[maxn];
vector<int> temp;
vector<int> ans; 
int maxm = -1;
void dfs(int root){
	temp.push_back(root);
	if(G[root].size()==0){
		int S = temp.size();
		if(S>maxm){
			maxm = S;
			ans = temp;
		}else if(S == maxm){
			if(temp<ans){
				ans = temp;
			}
		}
	}else{
		for(int i=0;i<G[root].size();i++){
			int v = G[root][i];
			dfs(v);
		}
	}
	temp.pop_back();
}
int main(){
	cin >> N;
	for(int i=0;i<N;i++){
		int K;
		cin >> K;
		for(int j=0;j<K;j++){
			int t;
			cin >> t;
			G[i].push_back(t);
			hashT[t] = true;
		}
	}
	int root = -1;
	for(int i=0;i<N;i++){
		if(!hashT[i]){
			root = i;
			break;
		}
	}
	dfs(root);
	cout << ans.size() << endl;
	for(int i=0;i<ans.size();i++){
		if(i==0){
			cout << ans[i];
		}else{
			cout << " " << ans[i];
		}
	}
	return 0;
}

L2-039 清点代码库 (25 分)

算法标签: 哈希 + 排序
注意点: 这道题考察哈希算法，我们需要将一串“输出值”，通过哈希函数映射成一个数，从而满足题目中的查询要求，这里采用STL的map容器实现
首先读入不同模块的输入，若该组输入在哈希表中出现过，那么我们只需要将该模块的计数器+1，若没有出现过，那么我们需要在哈希表中建立一个映射，并将模块计数器初始化为1，输入结束后，我们对结构体进行排序，得到最终的答案！

#include<bits/stdc++.h>
using namespace std;
vector<int> V[10005];
struct node{
	int number;
	int ans = 0;
};
node r[10005];

map<vector<int>,int> mp;
map<int,vector<int> > mp2;
bool cmp(node r1,node r2){
	if(r1.ans!=r2.ans){
		return r1.ans > r2.ans;
	}else{
		vector<int> v1;
		vector<int> v2;
		v1 = mp2[r1.number];
		v2 = mp2[r2.number];
		return v1 < v2;
	}
}
int main(){
	int N,M;
	scanf("%d%d",&N,&M);
	for(int i=1;i<=N;i++){
		for(int j=1;j<=M;j++){
			int t;
			scanf("%d",&t);
			V[i].push_back(t);
		}
	}
	int cnt = 0;
	for(int i=1;i<=N;i++){
		if(mp.find(V[i])==mp.end()){
			mp[V[i]] = ++cnt;
			mp2[cnt] = V[i];
			r[cnt].ans = 1;
			r[cnt].number = cnt;
		}else{
			r[mp[V[i]]].ans++;
		}
	}
	sort(r+1,r+1+cnt,cmp);
	printf("%d\n",cnt);
	for(int i=1;i<=cnt;i++){
		printf("%d",r[i].ans);
		vector<int> v = mp2[r[i].number];
		for(int j=0;j<v.size();j++){
			printf(" %d",v[j]);
		}
		printf("\n");
	}
	return 0;
}

L2-040 哲哲打游戏 (25 分)

算法标签: 大模拟
注意点: 本题考察的算法是大模拟，按照题目的要求，模拟游戏的读档、存档操作，哈希数组用来存档，读取也从该数组中取出，注意本题的剧本从1开始

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+5;
int hashT[105];
vector<int> G[maxn];
int main(){
	int N,M;
	scanf("%d%d",&N,&M);
	for(int i=1;i<=N;i++){
		int K;
		scanf("%d",&K);
		for(int j=1;j<=K;j++){
			int t;
			scanf("%d",&t);
			G[i].push_back(t);
		} 
	}
	int start = 1;
	for(int i=1;i<=M;i++){
		int op,x;
		scanf("%d%d",&op,&x);
		if(op == 0){
			start = G[start][x-1];
		}else if(op == 1){
			hashT[x] = start;
			printf("%d\n",start);
		}else{
			start = hashT[x];
		}
	}
	printf("%d\n",start);
	return 0;
} 

L2-041 插松枝（25分）

算法标签: 模拟 + 队列/栈
注意点: 易知本题考察的是队列/栈，小盒子是栈，推送器是队列
根据题目的要求，我们可以将其分成2个环节处理：推送器上还有小松针/推送器上没有小松针：
（1）推送器上还有小松针：此时先检查盒子内是否有松针，若有，则按要求不超过K个且满足松针大小单调不递增性质依次pop，直至不能pop时，若记录的小松针个数为K个，那么直接输出，否则，依次检查推送器上的小松针，满足要求的加入，直至K个输出；不满足要求的加入小盒子，此时若小盒子已满，也直接输出，这里的检查是序号单调递增的，N个检查完之后进入（2）环节，即没有小松针在推送器上了
（2）推送器上没有小松针：此时检查小盒子内是否有小松针，若有，则按要求不超过K个且满足松针大小单调非递增性质依次pop，直至empty

#include<bits/stdc++.h>
using namespace std;
int a[1005];
int b[1005];
int cnt = 1;
stack<int> s;
int main(){
	int N,M,K;
	scanf("%d%d%d",&N,&M,&K);
	for(int i=1;i<=N;i++){
		scanf("%d",&a[i]);
	}
	while(cnt<=N){
		int count = 0;
		int Height = 999;
		while(!s.empty() && count < K){
			if(s.top()<=Height){
				Height = s.top();
				b[++count] = s.top();
				s.pop();
			}else{
				break;
			}
		}
		if(count == K){
			for(int i=1;i<=count;i++){
				if(i == 1){
					printf("%d",b[i]);
				}else{
					printf(" %d",b[i]);
				}
			}
			printf("\n");
		}else{
			while(cnt<=N && count<K){
				if(a[cnt]<=Height){
					b[++count] = a[cnt];
					Height = a[cnt];
					cnt++;
				}else{
					int size = s.size();
					if(size<M){
						s.push(a[cnt]);
						cnt++;
					}else{
						break;
					}
				}
			}
			for(int i=1;i<=count;i++){
				if(i == 1){
					printf("%d",b[i]);
				}else{
					printf(" %d",b[i]);
				}
			}
			printf("\n");
		}
	}
	while(!s.empty()){
		int count = 0;
		int Height = 999; 
		while(!s.empty() && count<K && s.top()<=Height){
			b[++count] = s.top();
			Height = s.top();
			s.pop();
		}
		for(int i=1;i<=count;i++){
			if(i == 1){
				printf("%d",b[i]);
			}else{
				printf(" %d",b[i]);
			}
		}
		printf("\n");		
	}
	return 0;
} 

L2-042 老板的作息表（25分）

算法标签: 排序

#include<bits/stdc++.h>
using namespace std;
struct node{
	int start;
	int end;
};
const int maxn = 1e5+5;
node t[maxn];
bool cmp(node t1,node t2){
	if(t1.start!=t2.start){
		return t1.start < t2.start;
	}else{
		return t1.end < t2.end;
	}
}
int time_to_int(int h,int m,int s){
	return 3600*h + 60*m + s;
}
void int_to_time(int t1,int t2){
	int h1 = t1/3600;
	int m1 = t1%3600/60;
	int s1 = t1%60;
	int h2 = t2/3600;
	int m2 = t2%3600/60;
	int s2 = t2%60;
	printf("%02d:%02d:%02d - %02d:%02d:%02d\n",h1,m1,s1,h2,m2,s2);
}
int main(){
	int N;
	scanf("%d",&N);
	for(int i=1;i<=N;i++){
		int h1,h2,m1,m2,s1,s2;
		scanf("%d:%d:%d - %d:%d:%d",&h1,&m1,&s1,&h2,&m2,&s2);
		t[i].start = time_to_int(h1,m1,s1);
		t[i].end = time_to_int(h2,m2,s2);
	}
	sort(t+1,t+1+N,cmp);
	int begin = 0;
	for(int i=1;i<=N;i++){
		if(t[i].start>begin){
			int_to_time(begin,t[i].start);
			begin = t[i].end;
		}else{
			begin = t[i].end;
		}
	}
	if(begin!=86399){
		int_to_time(begin,86399);
	}
	return 0;
}

L2-043 龙龙送外卖（25分）

L2-044 大众情人（25分）

算法标签: 图论 + Floyd
注意点: Floyd模板题，算法细节具体可详见数据结构专题系列——最短路
本题需仔细理解这句话：我们记一个人$i$在一个异性$j$眼中的距离感为$D_{ij};$将$i$的“异性缘”定义为 $\frac{1}{ma{x}_{j\in S(i)}(D_{ij})}$，其中$S(i)$是相对于$i$的所有异性的集合。那么“大众情人”就是异性缘最好（值最大）的那个人。
要使得值最大，那么就是求$max(D_{ij})$最小的那组结果;
相对于$i$的所有异性的集合,这意味着我们比较的是j眼中的i尽可能小，用数据结构语言描述为dp[j][i]最小（注意不是dp[i][j]）

#include<bits/stdc++.h>
using namespace std;
int hashT[505];
int dp[505][505];
int res[505];

int main(){
	int N,M;
	scanf("%d%d",&N,&M);
	memset(dp,0x3f,sizeof(dp));
	for(int i=1;i<=N;i++){
		dp[i][i] = 0;
	}
	for(int i=1;i<=N;i++){
		char sex;
		cin >> sex;
		if(sex == 'F'){
			hashT[i] = 2;
		}else{
			hashT[i] = 1;
		}
		int K;
		scanf("%d",&K);
		for(int j=1;j<=K;j++){
			int num,dis;
			scanf("%d:%d",&num,&dis);
			dp[i][num] = min(dp[i][num],dis);
		}
	}
	for(int k=1;k<=N;k++){
		for(int i=1;i<=N;i++){
			for(int j=1;j<=N;j++){
				dp[i][j] = min(dp[i][j],dp[i][k]+dp[k][j]);	
			}
		}	
	}
	int maxm = INT_MAX;
	for(int i=1;i<=N;i++){
		if(hashT[i] == 2){
			int maxt = -1;
			for(int j=1;j<=N;j++){
				if(hashT[j] == 1){
					maxt = max(maxt,dp[j][i]);
				}
			}
			maxm = min(maxm,maxt);
		}
	}
	int cnt = 0;
	for(int i=1;i<=N;i++){
		if(hashT[i] == 2){
			int maxt = -1;
			for(int j=1;j<=N;j++){
				if(hashT[j] == 1){
					maxt = max(maxt,dp[j][i]); 
				}
			}
			if(maxt == maxm){
				if(!cnt){
					printf("%d",i);
				}else{
					printf(" %d",i);
				}
				cnt++;
			}
		} 
	}
	printf("\n");
	maxm = INT_MAX;
	cnt = 0;
	for(int i=1;i<=N;i++){
		if(hashT[i] == 1){
			int maxt = -1;
			for(int j=1;j<=N;j++){
				if(hashT[j] == 2){
					maxt = max(maxt,dp[j][i]);
				}
			}
			maxm = min(maxm,maxt);
		}
	}
	for(int i=1;i<=N;i++){
		if(hashT[i] == 1){
			int maxt = -1;
			for(int j=1;j<=N;j++){
				if(hashT[j] == 2){
					maxt = max(maxt,dp[j][i]); 
				}
			}
			if(maxt == maxm){
				if(!cnt){
					printf("%d",i);
				}else{
					printf(" %d",i);
				}
				cnt++;
			}
		} 
	}
	printf("\n");
	return 0;
}