PAT甲级题

A 1001

#include<cstdio>
int main(){
	int a,b,res[10];
	long long sum;
	scanf("%d%d",&a,&b);
	sum=a+b;
	if(sum<0){
		sum=-sum;
		printf("-");
	}
	int i=0;
	if(sum==0) printf("0");
	while(sum>0){
		res[i++]=sum%10;
		sum=sum/10;
	}
	for(int j=i-1;j>=0;j--){
		printf("%d",res[j]);
		if(j%3==0&&j!=0) printf(",");
	}
	return 0;
}

A1002(多项式求和)

#include<cstdio>
#include<string.h>
const int maxn=1001;
int count1,count2;
double coe[maxn]={},a;
int number=0;
int main(){
	scanf("%d",&count1);
	while(count1--){
		int i;
	    scanf("%d%lf",&i,&a);
		coe[i]=coe[i]+a;
	}
	scanf("%d",&count2);
	while(count2--){
        int k;
		scanf("%d%lf",&k,&a);
		coe[k]=coe[k]+a;
	}
	for(int k=maxn-1;k>=0;k--){
		if(coe[k]!=0){
			number++;
		}
	}
    printf("%d",number);
	for(int k=maxn-1;k>=0;k--){
		if(coe[k]!=0) printf(" %d %.1f",k,coe[k]);
	}
	return 0;
} 

A1003

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=510;
const int INF=1000000000;
int weight[maxn],d[maxn],w[maxn],num[maxn],G[maxn][maxn];
int n;
bool vis[maxn]={false};
void dijks(int s){
	fill(d,d+maxn,INF);
	fill(num,num+maxn,0);
	fill(w,w+maxn,0);
	w[s]=weight[s];
	d[s]=0;
	num[s]=1;
	for(int i=0;i<n;i++){
		int u=-1,MIN=INF;
		for(int j=0;j<n;j++){
			if(vis[j]==false&&d[j]<MIN){
				u=j;
				MIN=d[j];
			}
		}
		if(u==-1) return;
		vis[u]=true;
		for(int v=0;v<n;v++){
			if(vis[v]==false&&G[u][v]!=INF){
				if(d[u]+G[u][v]<d[v]){
					num[v]=num[u];
					d[v]=d[u]+G[u][v];
					w[v]=w[u]+weight[v];
				}else if(d[u]+G[u][v]==d[v]){
					if(w[v]<w[u]+weight[v]){
						w[v]=w[u]+weight[v];
					}
					num[v]+=num[u];
				}
			}
		}
	}
}
int main(){
	int m,st,end;
	scanf("%d%d%d%d",&n,&m,&st,&end);
	for(int i=0;i<n;i++) scanf("%d",&weight[i]);
	fill(G[0],G[0]+maxn*maxn,INF);
	for(int i=0;i<m;i++){
		int c1,c2;
		scanf("%d%d",&c1,&c2);
		scanf("%d",&G[c1][c2]);
		G[c2][c1]=G[c1][c2]; 
	}
	dijks(st);
	printf("%d %d",num[end],w[end]);
	return 0;
}

A1004

1.DFS法
#include<cstdio>
#include<vector>
using namespace std;
const int maxn = 110;
int hashtable[maxn] = { 0 };
vector<int> child[maxn];
int n,m,totallevel=0;
void DFS(int index, int level) {
	if (child[index].size() == 0) {
		hashtable[level]++;
		if (level > totallevel) totallevel=level;
		return;
	}
	for (int i = 0; i < child[index].size(); i++) {
		DFS(child[index][i], level + 1);
	}
}
int main() {
	scanf("%d%d", &n, &m);
	int father,num,temp;
	while (m--) {
		scanf("%d%d", &father, &num);
		while (num--) {
			scanf("%d", &temp);
			child[father].push_back(temp);
		}
	}
	DFS(1, 0);
	for (int i = 0; i <= totallevel; i++) {
		printf("%d", hashtable[i]);
		if (i < totallevel) printf(" ");
	}
	return 0;
}

2.BFS法
#include<cstdio>
#include<queue>
#include<algorithm>
using namespace std;
const int maxn = 110;
int hashtable[maxn] = { 0 };
vector<int> child[maxn];
int n, m, level[maxn] = { 0 },maxlevel=0;
void BFS() {
	level[1] = 1;
	queue<int> q;
	q.push(1);
	while (!q.empty()) {
		int now = q.front();
		q.pop();
		if (child[now].size() == 0) {
			hashtable[level[now]]++;
			maxlevel = max(maxlevel, level[now]);
		}
		for (int i = 0; i < child[now].size(); i++) {
			level[child[now][i]] = level[now] + 1;
			q.push(child[now][i]);
		}
	}
}
int main() {
	scanf("%d%d", &n, &m);
	int father,num,temp;
	while (m--) {
		scanf("%d%d", &father, &num);
		while (num--) {
			scanf("%d", &temp);
			child[father].push_back(temp);
		}
	}
	BFS();
	for (int i = 1; i <= maxlevel; i++) {
		printf("%d", hashtable[i]);
		if (i < maxlevel) printf(" ");
	}
	return 0;
}

A1005

#include<cstdio>
#include<string>
#include<cstring>
using namespace std;
int main(){
	int res[3],sum[110],i,result=0;
	char number[110];
	string english[10]={"zero","one","two","three","four","five","six","seven","eight","nine"};
	scanf("%s",number);
	int len=strlen(number);
	for(i=0;i<len;i++){
		sum[i]=number[i]-'0';
		result+=sum[i];
	}
	int j=0;
	if(result==0) printf("zero");
	while(result){
		res[j++]=result%10;
		result/=10;
	}
	for(int x=j-1;x>=0;x--){
		printf("%s",english[res[x]].c_str());
		if(x!=0) printf(" ");
	}
	return 0;
}

A1006

#include<cstdio> 

struct person {
	char id[16];
	int hh, mm, ss;
}temp,first,last;
bool great(person node1, person node2) {
	if (node1.hh != node2.hh) return node1.hh > node2.hh;
	if (node2.mm != node2.mm) return node1.mm > node2.mm;
	return node1.ss > node2.ss;
}
int main() {
	int n;
	scanf("%d", &n);
	first.hh = 24, first.mm = 60, first.ss = 60;
	last.hh = 0, last.mm = 0, last.ss = 0;
	for (int i = 0; i < n; i++) {
		scanf("%s %d:%d:%d", temp.id, &temp.hh, &temp.mm, &temp.ss);
		if (great(temp, first) == false)  first = temp;
		scanf("%d:%d:%d", &temp.hh, &temp.mm, &temp.ss);
		if (great(temp, last))   last = temp;
	}
	printf("%s %s", first.id, last.id);
	return 0;
}

A1007

#include<cstdio>
const int maxn=10010;
int a[maxn],dp[maxn],s[maxn]={0};
int main(){
	int n;
	scanf("%d",&n);
	bool flag=false;
	for(int i=0;i<n;i++){
		scanf("%d",&a[i]);
		if(a[i]>=0) flag=true;
	}
	if(flag==false){
		printf("0 %d %d",a[0],a[n-1]);
		return 0;
	}
	dp[0]=a[0];
	for(int i=1;i<n;i++){
		if(a[i]>dp[i-1]+a[i]){
			dp[i]=a[i];
			s[i]=i;
		} 
		else {
			dp[i]=dp[i-1]+a[i];
			s[i]=s[i-1];
		}
	}
	int k=0;
	for(int i=1;i<n;i++){
		if(dp[i]>dp[k]){
			k=i;
		}
	}
	printf("%d %d %d",dp[k],a[s[k]],a[k]);
	return 0;
}

A1008

#include <iostream>
using namespace std;
int main()
{
	int n,a[100000],totaltime=0;
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> a[i];
		if (i == 0) totaltime = a[i] * 6 + 5;
		else {
			if (a[i] > a[i - 1]) totaltime +=(a[i] - a[i - 1]) * 6 + 5;
			else totaltime += ((a[i-1] - a[i]) * 4 + 5);
		}
	}
	cout << totaltime;
	return 0;
}

A1009 多项式相乘

#include<cstdio>
#include<string.h>
const int maxn=2001;
int count1,count2;
struct poly{
	int exp;
	double coef;
}coe[1001];
double result[maxn];
int number=0;
int main(){
	scanf("%d",&count1);
for(int i =0;i<count1;i++){
	scanf("%d%lf",&coe[i].exp,&coe[i].coef);
    }
	scanf("%d",&count2);
for(int i=0;i<count2;i++){
	int k;
	double a;
		scanf("%d%lf",&k,&a);
		for(int i=0;i<count1;i++){
			result[k+coe[i].exp]+=(a*coe[i].coef);
		}
	}
	for(int k=maxn-1;k>=0;k--){
		if(result[k]!=0){
			number++;
		}
	}
    printf("%d",number);
	for(int k=maxn-1;k>=0;k--){
		if(result[k]!=0) printf(" %d %.1f",k,result[k]);
	}
	return 0;
} 

A1010 二分

#include<cstdio>
#include<iostream>
#include<cctype>
#include<algorithm>
#include<cmath>
#include<string>
using namespace std;
long long convert_to10(string n, long long radix) {
	int temp=0, index = 0;
	long long sum = 0;
	for (auto it = n.rbegin(); it != n.rend(); it++) {
		temp = isdigit(*it) ? *it - '0' : *it - 'a' + 10;
		sum += temp * pow(radix, index++);
	}
	return sum;
}
long long find_radix(string n, long long num) {
	char it = *max_element(n.begin(), n.end());
	long long low = (isdigit(it) ? it - '0' : it - 'a' + 10) + 1;
	long long high = max(low, num);
	while (low <= high) {
		long long mid = (low + high) / 2;
		long long t = convert_to10(n, mid);
		if (t > num || t < 0) high = mid - 1;
		else if (t == num) return mid;
		else if (t < num)  low = mid + 1;
	}
	return -1;
}
int main() {
	string n1, n2;
	int tag;
	long long radix;
	cin >> n1 >> n2 >> tag >> radix;
	long long ans = tag == 1 ? find_radix(n2, convert_to10(n1, radix)) : find_radix(n1, convert_to10(n2, radix));
	if (ans == -1) printf("Impossible");
	else printf("%lld", ans);
	return 0;
}

A1011

#include<cstdio> 
char s[4] = "WTL";
double a,res=1;
int main() {
	for (int i = 0; i < 3; i++) {
		int imax;
		double temp = 0;
		for (int i = 0; i < 3; i++) {
			scanf_s("%lf", &a);
			if (a > temp) {
				temp = a;
				imax = i;
			}
		}
		res *= temp;
		printf("%c ", s[imax]);
	}
	printf("%.2f", (res * 0.65 - 1) * 2);
	return 0;
}

A1012

#include<cstdio>
#include<algorithm>
using namespace std;
struct node {
	int id;
	int grade[4];
}stu[2100];
int now;
bool cmp(node a, node b) {return a.grade[now] > b.grade[now];}
int rank_stu[1000000][4] = { 0 };
char course[4] = { 'A','C','M','E' };
int main() {
	int n, m;
	scanf("%d%d", &n, &m);
	for (int i = 0; i < n; i++) {
		scanf("%d%d%d%d", &stu[i].id, &stu[i].grade[1], &stu[i].grade[2], &stu[i].grade[3]);
		stu[i].grade[0] = stu[i].grade[1] + stu[i].grade[2] + stu[i].grade[3];
	}
	for (now = 0; now < 4; now++) {
		sort(stu, stu + n, cmp);
		rank_stu[stu[0].id][now] = 1;
		for (int i = 1; i < n; i++) {
			if (stu[i].grade[now] == stu[i - 1].grade[now]) rank_stu[stu[i].id][now] = rank_stu[stu[i - 1].id][now];
			else rank_stu[stu[i].id][now] = i+1;
		}
	}
	int query;
	for (int i = 0; i < m; i++) {
		scanf("%d", &query);
		if (rank_stu[query][0] == 0) printf("N/A\n");
		else {
			int best=0;
			for (int j = 0; j < 4; j++) {
				if (rank_stu[query][j] < rank_stu[query][best])
					best = j;
			}
			printf("%d %c\n", rank_stu[query][best], course[best]);
		}
	}
	return 0;
}

A1013

#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
const int maxn=1010;
vector<int> G[maxn];
bool vis[maxn]={false};
int deletepoint;
void DFS(int v){
	if(v==deletepoint) return;
	vis[v]=true;
	for(int i=0;i<G[v].size();i++){
		if(vis[G[v][i]]==false){
			DFS(G[v][i]);
		}
	}
}
int main(){
	int n,m,k;
	scanf("%d%d%d",&n,&m,&k);
	while(m--){
		int a,b;
		scanf("%d%d",&a,&b);
		G[a].push_back(b);
		G[b].push_back(a);
	}
	for(int i=0;i<k;i++){
		int block=0;
		scanf("%d",&deletepoint);
		fill(vis,vis+maxn,false);
		for(int j=1;j<=n;j++){
			if(j!=deletepoint&&vis[j]==false){
				DFS(j);
				block++;
			}
		}
		printf("%d\n",block-1);
	}
	return 0;
}

A1015

#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
bool isprime(int n) {
	if (n <= 1) return false;
	int sqr = (int)sqrt(n * 1.0);
	for (int i = 2; i <= sqr; i++) {
		if (n % i == 0) return false;
	}
	return true;
}
int change(int n,int b) {
	int res[20],ans=0;
	int j = 0;
	do {
		res[j++] = n % b;
		n = n / b;
	} while (n != 0);
	reverse(res, res+ j);
	for (int i = 0; i < j; i++) {
		ans += res[i] * pow(b*(1.0), i*(1.0));
	}
	return ans;
}
int main() {
	while (1) {
		int num, radix;
		scanf_s("%d", &num);
		if (num < 0) break;
		else {
			scanf_s("%d", &radix);
			int ans = change(num, radix);
			if (isprime(num) && isprime(ans)) printf("Yes\n");
			else printf("No\n");
		}
	}
	return 0;
}

A1016

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn = 1010;
int toll[24];
struct Record {
	char name[21];
	int mon, dd, hh, mm;
	bool status;
}rec[maxn],temp;
bool cmp(Record a, Record b) {
	if (strcmp(a.name, b.name) != 0) return strcmp(a.name, b.name) < 0;
	else if (a.mon != b.mon) return a.mon < b.mon;
	else if (a.dd != b.dd) return a.dd < b.dd;
	else if (a.hh != b.hh) return a.hh < b.hh;
	else return a.mm < b.mm;
}
void get_ans(int on, int off, int& time, int& money) {
	temp = rec[on];
	while (temp.dd < rec[off].dd || temp.hh < rec[off].hh || temp.mm < rec[off].mm) {
		time++;
		money += toll[temp.hh];
		temp.mm++;
		if (temp.mm >= 60) {
			temp.mm = 0;
			temp.hh++;
		}
		if (temp.hh >= 24) {
			temp.hh = 0;
			temp.dd++;
		}
	}
}
int main() {
	char line_status[10];
	int n;
	for (int i = 0; i < 24; i++) scanf("%d", &toll[i]);
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%s %d:%d:%d:%d %s", rec[i].name, &rec[i].mon, &rec[i].dd, &rec[i].hh, &rec[i].mm,line_status);
		if (strcmp(line_status, "on-line") == 0) rec[i].status = true;
		if (strcmp(line_status, "off-line") == 0) rec[i].status = false;
	}
	sort(rec, rec + n, cmp);
	int on = 0, off, next;
	while (on < n) {//每次处理一个用户的所有记录
		int needprint = 0;
		next = on;
		while (next < n && strcmp(rec[next].name, rec[on].name) == 0) {//判断是否有配对项
			if (rec[next].status == true && needprint == 0) needprint = 1;
			else if (rec[next].status == false && needprint == 1) needprint = 2;
			next++;
		}
		if (needprint < 2) {
			on = next;
			continue;
		}
		int allmoney = 0;
		printf("%s %02d\n", rec[on].name, rec[on].mon);
		while (on < next) {
			while (on < next - 1 && !(rec[on].status == true && rec[on + 1].status == false)) on++;
			off = on + 1;
			if (off == next) {
				on = next;
				break;
			}
			int time = 0;
			int  money = 0;
			get_ans(on, off, time, money);
			allmoney += money;
			printf("%02d:%02d:%02d ", rec[on].dd, rec[on].hh, rec[on].mm);
			printf("%02d:%02d:%02d ", rec[off].dd, rec[off].hh, rec[off].mm);
			printf("%d $%.2f\n", time, money / 100.0);
			on=off+1;
		}
		printf("Total amount:$%.2f\n", double(allmoney) / 100);
	}
	return 0;
}

A1018

#include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;
const int  maxn=510;
const int INF=1000000000;
int minneed=INF,minremain=INF,cmax,n,sp,m;
int G[maxn][maxn],d[maxn],weight[maxn];
vector<int> path,temppath;
vector<int>pre[maxn];
bool vis[maxn]={false};
void dijkst(int s){
	fill(d,d+maxn,INF);
	d[s]=0;
	for(int i=0;i<=n;i++){
		int u=-1,MIN=INF;
		for(int j=0;j<=n;j++){
			if(vis[j]==false&&d[j]<MIN){
				u=j;
				MIN=d[u];
			}
		}
		if(u==-1) return;
		vis[u]=true;
		for(int v=0;v<=n;v++){
			if(vis[v]==false&&G[u][v]!=INF){
				if(d[v]>d[u]+G[u][v]){
					d[v]=d[u]+G[u][v];
					pre[v].clear();
					pre[v].push_back(u);
				}else if(d[v]==G[u][v]+d[u]){
					pre[v].push_back(u);
				}
			}
		}
	}
}
void DFS(int v){
	if(v==0){
		temppath.push_back(v);
		int need=0,remain=0;
		for(int i=temppath.size()-1;i>=0;i--){
			int id=temppath[i];
			if(weight[id]>0){
				remain+=weight[id];
			}else{
				if(abs(weight[id])<remain){
					remain-=abs(weight[id]);
				}else {
					need+=abs(weight[id])-remain;
					remain=0;
				}
			}
		} 
		if(need<minneed){
			minneed=need;
			minremain=remain;
			path=temppath;
		}else if(need==minneed&&remain<minremain){
			minremain=remain;
			path=temppath;
		}
		temppath.pop_back();
		return;
	}
	temppath.push_back(v);
	for(int i=0;i<pre[v].size();i++){
		DFS(pre[v][i]);
	}
	temppath.pop_back();
}
int main(){
	scanf("%d%d%d%d",&cmax,&n,&sp,&m);
	fill(G[0],G[0]+maxn*maxn,INF);
	for(int i=1;i<=n;i++){
		scanf("%d",&weight[i]);
		weight[i]-=cmax/2;
	}
	for(int i=1;i<=m;i++){
		int a,b;
		scanf("%d%d",&a,&b);
		scanf("%d",&G[a][b]);
		G[b][a]=G[a][b];
	}
	dijkst(0);
	DFS(sp);
	printf("%d ",minneed);
	for(int i=path.size()-1;i>=0;i--){
		printf("%d",path[i]);
		if(i>0) printf("->");
	}
	printf(" %d",minremain);
	return 0;
}

A1019

#include<cstdio>
#include<vector>
using namespace std;
vector<int> a,c;
void change(int n,int b){
	if(n>0){
		int i=0;
		change(n/b,b);
		a.push_back(n%b);
	}
	else return;
}
bool judge(vector<int> a,vector<int> b){
	for(int i=0;i<a.size();i++){
		if (a[i]==b[i]) continue;
		else return false;
	}
	return true;
}
int main(){
	int n,b;
	scanf("%d %d",&n,&b);
	change(n,b);
	for(int i=0;i<a.size();i++){
		c.push_back(a[i]);
	}
	for (int min = 0, max = a.size()-1; min <= max; min++, max--) {
		int temp = a[min];
		a[min] = a[max];
		a[max] = temp;
	}
	if(judge(a,c)==true){
		printf("Yes\n");
		for(int i=0;i<c.size();i++){
			printf("%d",c[i]);
			if(i!=c.size()-1) printf(" ");
		}
	}
	if(judge(a,c)==false) {
		printf("No\n");
		for(int i=0;i<c.size();i++){
			printf("%d",c[i]);
			if(i!=c.size()-1) printf(" ");
		}
	}
	return 0;
}

A1020

#include<cstdio>
#include<queue>
using namespace std;
int postorder[31], inorder[31], n;
struct node {
	int data;
	node* lchild;
	node* rchild;
};
node* create(int postL, int postR, int inL, int inR) {
	if (postL > postR) return NULL;
	node* root = new node;
	root->data = postorder[postR];
	int k;
	for (int i = inL; i <= inR; i++) {
		if (inorder[i] == root->data) {
			k = i;
			break;
		}
	}
	int leafnum = k - inL;
	root->lchild = create(postL, postL + leafnum - 1, inL, k - 1);
	root->rchild = create(postL + leafnum, postR - 1, k + 1, inR);
	return root;
}
int num = 0;
void layerorder(node* root) {
	queue<node*> q;
	q.push(root);
	while (!q.empty()) {
		node* now = q.front();
		q.pop();
		printf("%d", now->data);
        num++;
		if (num < n) printf(" ");
		if (now->lchild != NULL) q.push(now->lchild);
		if (now->rchild != NULL) q.push(now->rchild);
	}
}
int main() {
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &postorder[i]);
	}
	for (int i = 0; i < n; i++) {
		scanf("%d", &inorder[i]);
	}
	node* root = create(0, n - 1, 0, n - 1);
	layerorder(root);
	return 0;
}

A1021

#include<cstdio>
#include<set>
#include<vector>
#include<algorithm>
using namespace std;
const int maxn=10010;
vector<vector<int> > G;
set<int> ans;
vector<int> temp;
bool vis[maxn]={false};
int maxheight=0;
void DFS(int node,int height){
	if(height>maxheight){
		maxheight=height;
		temp.clear();
		temp.push_back(node);
	}else if(height==maxheight){
		temp.push_back(node);
	}
	vis[node]=true;
	for(int i=0;i<G[node].size();i++){
		if(vis[G[node][i]]==false){
			DFS(G[node][i],height+1);
		}
	}
}
int main(){
	int n,count=0,select1;
	scanf("%d",&n);
	G.resize(n+1);
	for(int i=0;i<n-1;i++){
		int a,b;
		scanf("%d%d",&a,&b);
		G[a].push_back(b);
		G[b].push_back(a);
	}
	for(int i=1;i<=n;i++){
		if(vis[i]==false){
			DFS(i,1);
		    if(i==1){
			   if(temp.size()!=0) select1=temp[0];
			   for(int j=0;j<temp.size();j++)	ans.insert(temp[j]);
	    	}
	    	count++;
		} 	
	}
	if(count>=2) printf("Error: %d components",count);
	else{
		temp.clear();
		maxheight=0;
		fill(vis,vis+maxn,false);
		DFS(select1,1);
		for(int i=0;i<temp.size();i++) ans.insert(temp[i]);
		for(auto it=ans.begin();it!=ans.end();it++) printf("%d\n",*it);
	}
	return 0;
}

A1022

#include<cstdio>
#include<iostream>
#include<map>
#include<set>
#include<string>
using namespace std;
map<string, set<int> > mptitle, mpautor, mpkey, mppublish, mpyear;
void query(map<string, set<int> >& mp, string& str) {
	if (mp.count(str) == 0) cout << "Not Found\n";
	else {
		for (auto it = mp[str].begin(); it != mp[str].end(); it++) {
			printf("%07d\n", *it);
		}
	}
}
int main() {
	int n,m,id;
	cin >> n;
	string title, autor, keyword, publish, year;
	for (int i = 0; i < n; i++) {
		cin >> id;
		char c = getchar();
		getline(cin, title);
		mptitle[title].insert(id);
		getline(cin, autor);
		mpautor[autor].insert(id);
		while (cin >> keyword) {
			mpkey[keyword].insert(id);
			 c = getchar();
			if (c == '\n') break;
		}
		getline(cin, publish);
		mppublish[publish].insert(id);
		getline(cin, year);
		mpyear[year].insert(id);
	}
	cin >> m;
	while(m--){
		int type;
		string temp;
		scanf("%d: ", &type);
		getline(cin, temp);
		cout << type << ":" << " " << temp<<endl;
		if (type == 1) query(mptitle, temp);
		if (type == 2) query(mpautor, temp);
		if (type == 3) query(mpkey, temp);
		if (type == 4) query(mppublish, temp);
		if (type == 5) query(mpyear, temp);
	}
	return 0;
}

A1023

#include<cstdio>
#include<iostream>
#include<string>
#include<cstring>
using namespace std;
struct bign {
	int d[1000];
	int len;
	bign() {
		len = 0;
		memset(d, 0, sizeof(d));
	}
};
bign change(string str) {
	bign a;
	a.len = str.length();
	for (int i = 0; i < a.len; i++) {
		a.d[i] = str[a.len - 1 - i]-'0';
	}
	return a;
}
bign multi(bign a, int b) {
	bign c;
	int carry=0;
	for (int i = 0; i < a.len; i++) {
		int temp = a.d[i] * b + carry;
		c.d[c.len++] = temp % 10;
		carry = temp / 10;
	}
	while (carry != 0) {
		c.d[c.len++] = carry % 10;
		carry /= 10;
	}
	return c;
}
bool judge(bign a, bign b) {
	if (a.len != b.len) return false;
	else {
		int count[10] = { 0 };
		for (int i = 0; i < a.len; i++) {
			count[a.d[i]]++;
			count[b.d[i]]--;
		}
		for (int i = 0; i < 10; i++) {
			if (count[i] != 0) {
				return false;
			}
		}
	}
	return true;
}
void print(bign a) {
	for (int i = a.len - 1; i >= 0; i--) {
		printf("%d", a.d[i]);
	}
}
int main() {
	string str;
	cin >> str;
	bign a, ans;
	a=change(str);
	ans = multi(a, 2);
	if (judge(a, ans)) cout << "Yes" << endl;
	else cout << "No" << endl;
	print(ans);
	return 0;
}

A1024

#include<cstdio>
#include<iostream>
#include<string>
#include<cstring>
#include<algorithm>
using namespace std;
struct bign {
	int d[100];
	int len;
	bign() {
		len = 0;
		memset(d, 0, sizeof(d));
	}
};
bign change(string str) {
	bign res;
	res.len = str.size();
	for (int i = 0; i < res.len; i++) {
		res.d[i] = str[res.len - 1 - i]-'0';
	}
	return res;
}
bign add(bign a, bign b) {
	bign c;
	int carry=0;
	for (int i = 0; i < a.len || i < b.len; i++) {
		int temp = a.d[i] + b.d[i] + carry;
		c.d[c.len++] = temp % 10;
		carry = temp / 10;
	}
	if (carry != 0) {
		c.d[c.len++] = carry % 10;
	}
	return c;
}
bool judge(bign a) {
	for (int i = 0; i <= a.len / 2; i++) {
		if (a.d[i] != a.d[a.len - 1 - i]) {
			return false;
		}
	}
	return true;
}
void print(bign a) {
	for (int i = a.len - 1; i >= 0; i--) {
		printf("%d", a.d[i]);
	}
	cout << endl;
}
int main() {
	string str;
	int k;
	cin >> str;
	cin >> k;
	bign ans=change(str);
	int i;
	for ( i = 0; i < k; i++) {
		if (judge(ans)) break;
		bign temp = ans;
		reverse(temp.d, temp.d + temp.len);
		ans = add(temp, ans);
	}
	print(ans);
	if (i <= k) cout << i;
	else cout << k;
	return 0;
}

A1025

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct student{
	char id[15];
	int grade;
	int lrank,frank;
	int local_num;
}testee[30010];
bool cmp1(student a,student b){ 
     return a.grade>b.grade;
}
bool cmp2(student a,student b){
	if(a.frank!=b.frank) return a.frank<b.frank;
	else if(strcmp(a.id,b.id)!=0) return strcmp(a.id,b.id)<0;
}
int main(){
	int n;
	int total=0;
	int localnum=0;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		int temp;
		localnum++;
		int on,off;
		on=total;
		off=on;
		scanf("%d",&temp);
		for(int j=0;j<temp;j++){
			scanf("%s%d",testee[total].id,&testee[total].grade);
			testee[total].local_num=localnum;
			total++;
			off++;
		}
		sort(testee+on,testee+off,cmp1);
		testee[on].lrank=1;
		for(int k=on+1;k<off;k++){
			if(testee[k].grade==testee[k-1].grade) testee[k].lrank=testee[k-1].lrank;
			else testee[k].lrank=k-on+1;
		}
	}
	sort(testee,testee+total,cmp1);
	testee[0].frank=1;
	for(int k=1;k<total;k++){
		if(testee[k].grade==testee[k-1].grade) testee[k].frank=testee[k-1].frank;
		else testee[k].frank=k+1;
	}
	sort(testee,testee+total,cmp2);
	printf("%d\n",total);
	for(int i=0;i<total;i++){
		printf("%s %d %d %d\n",testee[i].id,testee[i].frank,testee[i].local_num,testee[i].lrank);
	}
	return 0;
}

A1027

#include<cstdio>
int a[2],b[2],c[2];
	void change(int x,int a[]){
		if(x==0) {
			a[0]=0;
			a[1]=0;
		}
		else{
			a[0]=x%13;
			if((x/13)==0) a[1]=0;
			else a[1]=(x/13)%13;
		}
	}
int main(){
	int red,green,blue;
	scanf("%d %d %d",&red,&green,&blue);
	char str[15]={'0','1','2','3','4','5','6','7','8','9','A','B','C'};
    change(red,a);
	printf("#%c%c",str[a[1]],str[a[0]]);
	change(green,b);
	printf("%c%c",str[b[1]],str[b[0]]);
	change(blue,c);
	printf("%c%c",str[c[1]],str[c[0]]);
	return 0;
} 

A1028

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn = 100010;
struct node {
	char id[10];
	char name[10];
	int grade;
}student[100010];
int c;
bool cmp(node a, node b) {
	if (c == 1) return strcmp(a.id, b.id) < 0;
	if (c == 2) {
		if (strcmp(a.name, b.name) != 0) return strcmp(a.name, b.name) < 0;
		else return strcmp(a.id, b.id) < 0;
	}
	if (c == 3) {
		if (a.grade != b.grade) return a.grade < b.grade;
		else return strcmp(a.id, b.id) < 0;
	}
}
int main() {
		int n;
		scanf("%d", &n);
		scanf("%d", &c);
		for (int i = 0; i < n; i++) scanf("%s%s%d", student[i].id, student[i].name, &student[i].grade);
		sort(student, student + n, cmp);
		for (int i = 0; i < n; i++) printf("%s%s%d\n", student[i].id, student[i].name, student[i].grade);
		return 0;
}

A1029

1.直接暴力
#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=400010;
int main(){
    int n1,n2;
    long long a[maxn];
    scanf("%d",&n1);
    int i;
    for( i=0;i<n1;i++){
        scanf("%lld",&a[i]);
    }
      scanf("%d",&n2);
    for( i=n1;i<n2+n1;i++){
        scanf("%lld",&a[i]);
    }
    sort(a,a+n1+n2);
    printf("%d",a[(n1+n2-1)/2]);
    return 0;
}

2.two points

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=400010;
const int INF=(1<<31)-1;
int main(){
    int n1,n2;
    long long a[maxn],b[maxn];
    scanf("%d",&n1);
    for(int i=0;i<n1;i++){
        scanf("%lld",&a[i]);
    }
      scanf("%d",&n2);
    for(int i=0;i<n2;i++){
        scanf("%lld",&b[i]);
    }
    a[n1]=INF;
    b[n2]=INF;
    int midpos=(n1+n2-1)/2;
    int count=0,j=0,i=0;
    while(count<midpos){
        if(a[i]<b[j]) i++;
        else j++;
        count++;
    }
    if(a[i]<b[j]) printf("%lld",a[i]);
    else printf("%lld",b[j]);
    return 0;
}

A1030

#include<cstdio>
#include<algorithm>
using namespace std;
const int  maxn=510;
const int INF=1000000000;
int n,m,st,destination;
int G[maxn][maxn],d[maxn],cost[maxn][maxn],pre[maxn],costtotal[maxn];
bool vis[maxn]={false};
void dijkst(int s){
	fill(d,d+maxn,INF);
	fill(costtotal,costtotal+maxn,INF);
	d[s]=0;
	costtotal[s]=0;
	for(int i=0;i<n;i++){
		int u=-1,MIN=INF;
		for(int j=0;j<n;j++){
			if(vis[j]==false&&d[j]<MIN){
				u=j;
				MIN=d[u];
			}
		}
		if(u==-1) return;
		vis[u]=true;
		for(int v=0;v<n;v++){
			if(vis[v]==false&&G[u][v]!=INF){
				if(d[v]>d[u]+G[u][v]){
					d[v]=d[u]+G[u][v];
					costtotal[v]=cost[u][v]+costtotal[u];
					pre[v]=u;
				}else if(d[v]==G[u][v]+d[u]&&costtotal[v]>costtotal[u]+cost[u][v]){
					costtotal[v]=cost[u][v]+costtotal[u];
					pre[v]=u;
				}
			}
		}
	}
}
void DFS(int v){
	if(v==st){
		printf("%d ",v);
		return;
	}
    DFS(pre[v]);
    printf("%d ",v);
}
int main(){
	scanf("%d%d%d%d",&n,&m,&st,&destination);
	fill(G[0],G[0]+maxn*maxn,INF);
	for(int i=1;i<=m;i++){
		int c1,c2,dis,cos;
		scanf("%d%d",&c1,&c2);
		scanf("%d",&G[c1][c2]);
		G[c2][c1]=G[c1][c2];
		scanf("%d",&cost[c1][c2]);
		cost[c2][c1]=cost[c1][c2];
	}
	dijkst(st);
	DFS(destination);
	printf("%d %d",d[destination],costtotal[destination]);
	return 0;
}

A1031

#include<cstdio> 
#include<cstring>
int main() {
	char str[100], uu[40][40];
    scanf("%s",str); 
	int N = strlen(str);
	int n1=(N+2)/3;
	int n3=(N+2)/3;
	int n2=N-n1-n3+2;
	int pos=0;
    memset(uu,' ',sizeof(uu));
	for(int i=0;i<n1-1;i++){
		uu[i][0]=str[pos++];
	} 
	for(int j=0;j<n2;j++){
		uu[n1-1][j]=str[pos++];
	}
	for(int k=n3-2;k>=0;k--){
		uu[k][n2-1]=str[pos++];
	}
	for(int i=0;i<n1;i++){
		for(int j=0;j<n2;j++){
			printf("%c",uu[i][j]);
		}
		printf("\n");
	}
	return 0;
}

A1032(链表)

#include<cstdio>
const int maxn = 100010;
struct Node {
	int data;
	int next;
	bool flag;
}node[maxn];
int main() {
	int begin1, begin2, n;
	scanf("%d%d%d", &begin1, &begin2, &n);
	for (int i = 0; i < maxn; i++) {
		node[i].flag = false;
	}
	int address, data, next;
	for (int i = 0; i < n; i++) {
		scanf("%d %c %d", &address, &data, &next);
		node[address].data = data;
		node[address].next = next;
	}
	int p;
	for (p = begin1; p != -1; p = node[p].next) {
		node[p].flag = true;
	}
	for (p = begin2; p != -1; p = node[p].next) {
		if (node[p].flag == true) {
			printf("%05d", p);
			break;
		}
	}
	if (p == -1) {
		printf("-1");
	}
	return 0;
}

A1033

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn = 510;
const int INF = 1000000000;
struct node{
	double price;
	double distance;
}station[maxn];
bool cmp(node a, node b) {
	return a.distance < b.distance;
}
int main() {
	double cmax, d, davg;
	int n;
	scanf("%lf%lf%lf%d", &cmax, &d, &davg, &n);
	for (int i = 0; i < n; i++) {
		scanf("%lf%lf", &station[i].price, &station[i].distance);
	}
	station[n].distance = d;
	station[n].price = 0;
	sort(station, station + n + 1, cmp);
	if (station[0].distance != 0) {
		printf("The maximum travel distance = 0.00");
		return 0;
	}
	int now = 0;
	double nowtank = 0, expend = 0,  canrun = cmax * davg;
	while (now < n) {
        int k=-1;
        double minprice=INF;
		for (int i = now + 1; (station[i].distance - station[now].distance) <= canrun && i <= n; i++) {
			if (station[i].price < minprice) {
				minprice = station[i].price;
				k = i;
				if (minprice < station[now].price) {
					break;
				}
			}
		}
		if (k == -1) break;
		double need = (station[k].distance - station[now].distance) / davg;
		if (station[k].price < station[now].price) {
			if (nowtank < need) {
				expend += (need - nowtank) * station[now].price;
				nowtank = 0;
			}
			else {
				nowtank -= need;
			}
		}
		else {
			expend += (cmax - nowtank) * station[now].price;
			nowtank = cmax - need;
		}
		now = k;
	}
	if (now == n) printf("%.2f", expend);
	else printf("The maximum travel distance = %.2f", station[now].distance + canrun);
	return 0;
}

A1034

#include<iostream>
#include<map>
#include<string>
using namespace std;
const int maxn = 2100;
map<string, int> stringtoint;
map<int, string> inttostring;
map<string, int> gang;
int G[maxn][maxn] = { 0 }, numperson = 0, weight[maxn] = { 0 }, k;
bool vis[maxn] = { false };
void DFS(int visnow, int& head, int& nummember, int& totalvalue) {
	nummember++;
	vis[visnow] = true;
	if (weight[visnow] > weight[head]) head = visnow;
	for (int i = 0; i < numperson; i++) {
		if (G[visnow][i] > 0) {
			totalvalue += G[visnow][i];
			G[visnow][i] = 0;
			G[i][visnow] = 0;
            if (vis[i] == false) {
			DFS(i, head, nummember, totalvalue);
	 	  }
		}	
	}
}
void DFStrave() {
	for (int i = 0; i < numperson; i++) {
		if (vis[i] == false) {
			int head = i, nummember = 0, totalvalue = 0;
			DFS(i, head, nummember, totalvalue);
			if (totalvalue > k && nummember > 2) {
				gang[inttostring[head]] = nummember;
			}
		}
	}
}
int change(string str) {
	if (stringtoint.count(str) == 0) {
		stringtoint[str] = numperson;
		inttostring[numperson] = str;
		return numperson++;
	}
	else {
		return stringtoint[str];
	}
}
int main() {
	int n, phonetime;
	string str1, str2;
	cin >> n >> k;
	for (int i = 0; i < n; i++) {
		cin >> str1 >> str2 >> phonetime;
		int id1 = change(str1);
		int id2 = change(str2);
		weight[id1] += phonetime;
		weight[id2] += phonetime;
		G[id1][id2] += phonetime;
		G[id2][id1] += phonetime;
	}
	DFStrave();
	cout << gang.size() << endl;
	for (auto it = gang.begin();it!=gang.end();it++) {
		cout << it->first << " " << it->second << endl;
	}
	return 0;
}

A1035

#include<cstdio>
#include<cstring>
struct node {
	char name[11];
	char password[11];
	bool flag;
}user[1010];
int main() {
	int n, change = 0;;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%s%s", user[i].name, user[i].password);
		user[i].flag = false;
		int len1 = strlen(user[i].password);
		for (int j = 0; j < len1; j++) {
			if (user[i].password[j] == '1') {
				user[i].password[j] = '@';
				user[i].flag = true;
			}
			else if (user[i].password[j] == '0') {
				user[i].password[j] = '%';
				user[i].flag = true;
			}
			else if (user[i].password[j] == 'l') {
				user[i].password[j] = 'L';
				user[i].flag = true;
			}
			else if (user[i].password[j] == 'O') {
				user[i].password[j] = 'o';
				user[i].flag = true;
			}
		}
		if (user[i].flag == true) change++;
	}
	if (n == 1) printf("There is 1 account and no account is modified");
	else if (n > 1 && change == 0) printf("There are %d accounts and no account is modified", n);
	else if (n > 1 && change > 0) {
		printf("%d\n", change);
		for (int i = 0; i < n; i++) {
			if (user[i].flag == true) {
				printf("%s %s\n", user[i].name, user[i].password);
			}
		}
	}
	return 0;
}

A1036

#include<cstdio> 
#include<algorithm>
using namespace std;
struct student {
	char name[11];
	char gender;
	char id[11];
	int score;
}male,female,temp;
int main() {
	int n;
	scanf("%d", &n);
	female.score = -1;
	male.score = 101;
	for (int i = 0; i < n; i++) {
		scanf("%s %c %s %d", temp.name, &temp.gender, temp.id, &temp.score);
		if (temp.gender == 'F') {
			if (temp.score > female.score) {
				female = temp;
			}
		}
		if (temp.gender == 'M') {
			if (temp.score < male.score) {
				male = temp;
			}
		}
	}
	if (female.score == -1) printf("Absent\n");
	if (female.score > -1) printf("%s %s\n", female.name, female.id);
	if (male.score == 101) printf("Absent\n");
	if (male.score <101) printf("%s %s\n", male.name, male.id);
	if (female.score == -1 || male.score == 101) printf("NA");
	if (female.score > -1 && male.score < 101) printf("%d", female.score - male.score);
	return 0;
}

A1037

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn = 100010;
int main() {
	int coupon[maxn];
	int product[maxn];
	int n, m;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &coupon[i]);
	}
	scanf("%d", &m);
	for (int i = 0; i < m; i++) {
		scanf("%d", &product[i]);
	}
	sort(coupon, coupon + n);
	sort(product, product + m);
	int j = 0, ans = 0;
	while (j < n && coupon[j] < 0 && product[j] < 0 && j < m) {
		ans += coupon[j] * product[j];
		j++;
	}
	int k = n - 1, i = m - 1;
	while (k >= 0 && i >= 0 && coupon[k] > 0 && product[i] > 0) {
		ans += coupon[k] * product[i];
		k--;
		i--;
	}
	printf("%d", ans);
	return 0;
}

A1038

#include<cstdio>
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
const int maxn = 10010;
bool cmp(string a, string b) {
	return a + b < b + a;
}
int main() {
	int n;
	string str[maxn];
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		cin >> str[i];
	}
	sort(str, str + n, cmp);
	string ans;
	for (int i = 0; i < n; i++) {
		ans += str[i];
	}
	while (ans[0] == '0' && ans.size() != 0) {
		ans.erase(ans.begin());
	}
	if (ans.length() != 0) cout << ans;
	else cout << "0";
	return 0;
}

A1039

#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
const int maxn = 26 * 26 * 26 * 10 + 10;
vector<int> stu[maxn];
int getid(char name[]) {
	int id=0;
	for (int i = 0; i < 3; i++) 
		id = id * 26 + (name[i] - 'A');
	id = id * 10 + (name[3] - '0');
	return id;
}
int main() {
	int n, k, no, num;
	char name[5];
	scanf("%d%d", &n, &k);
	for (int i = 0; i < k; i++) {
		scanf("%d%d", &no, &num);
		for (int j = 0; j < num; j++) {
			scanf("%s", name);
			stu[getid(name)].push_back(no);
		}
	}
	for (int i = 0; i < n; i++) {
		scanf("%s", name);
		printf("%s ", name);
		printf("%d", stu[getid(name)].size());
		sort(stu[getid(name)].begin(), stu[getid(name)].end());
		for (int j = 0; j < stu[getid(name)].size(); j++) {
			printf(" %d", stu[getid(name)][j]);
		}
		printf("\n");
	}
	return 0;
}

A1040

#include<iostream>
#include<cstring>
#include<string>
using namespace std;
const int maxn=1010;
string str;
int dp[maxn][maxn];
int main(){
	memset(dp,0,sizeof(dp));
	getline(cin,str);
	int ans=1,len=str.length();
	for(int i=0;i<len;i++){
		dp[i][i]=1;
		if(i<len-1){
			if(str[i]==str[i+1]){
				dp[i][i+1]=1;
				ans=2;
			}
		}
	}
	for(int L=3;L<=len;L++){
		for(int i=0;i+L-1<len;i++){
			int j=i+L-1;
			if(str[i]==str[j]&&dp[i+1][j-1]==1){
				dp[i][j]=1;
				ans=L;
			}
		}
	}
	printf("%d",ans);
	return 0;
}

A1041

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn = 10010;
struct node {
	int choice;
	int num;
	int rank;
}bets[maxn];
bool cmp(node a, node b) {
	if (a.num != b.num) return a.num < b.num;
	else return a.rank < b.rank;
}
int main() {
	int n;
	scanf("%d", &n);
	for (int i = 0; i < maxn; i++) {
		bets[i].num = maxn;
		bets[i].rank = maxn;
	}
	for (int i = 0; i < n; i++) {
		int choice;
		scanf("%d", &choice);
		bets[choice].choice = choice;
		if (bets[choice].num == maxn) {
			bets[choice].num = 1;
		}
		else {
			bets[choice].num++;
		}
		if (bets[choice].rank == maxn) bets[choice].rank = i;
	}
	sort(bets, bets + maxn, cmp);
	if (bets[0].num == 1) printf("%d", bets[0].choice);
	else printf("None");
	return 0;
}

A1042

#include<cstdio>
const int N = 55;
int main()
{
	char mp[5] = { 'S','H','C','D','J' };
	int start[N], next[N], end[N];
	int times;
	scanf("%d", &times);
	for (int i = 1; i <= 54; i++) {
		scanf("%d", &next[i]);
	}
	for (int i = 1; i <= 54; i++) {
		start[i] = i;
	}
	for (int step = 0; step < times; step++) {
		for (int i = 1; i <= 54; i++) {
			end[next[i]] = start[i];
		}
		for (int i = 1; i <= 54; i++) {
			start[i] = end[i];
		}
	}
	for (int i = 1; i <= 54; i++) {
		if (i != 1) printf(" ");
		start[i]--;
		printf("%c%d", mp[start[i] / 13], start[i] % 13+1);
	}
	return 0;
}

A1043

#include<cstdio>
#include<vector>
using namespace std;
struct node{
	int data;
	node* lchild;
	node* rchild;
};
void insert(node*& root, int x) {
	if (root == NULL) {
		root = new node;
		root->data = x;
		root->lchild = NULL;
		root->rchild = NULL;
		return;
	}
	if (x < root->data) insert(root->lchild, x);
	else insert(root->rchild, x);
}
void preorder(node* root, vector<int>& vi) {
	if (root == NULL) return;
	vi.push_back(root->data);
	preorder(root->lchild,vi);
	preorder(root->rchild, vi);
}
void preMorder(node* root, vector<int>& vi) {
	if (root == NULL) return;
	vi.push_back(root->data);
	preMorder(root->rchild, vi);
	preMorder(root->lchild, vi);
}
void postorder(node*root,vector<int>& vi) {
	if (root == NULL) return;
	postorder(root->lchild,vi);
	postorder(root->rchild,vi);
	vi.push_back(root->data);
}
void postMorder(node* root, vector<int>& vi) {
	if (root == NULL) return;
	postMorder(root->rchild,vi);
	postMorder(root->lchild,vi);
	vi.push_back(root->data);
}
int main() {
	vector<int>origin, pre, preM, post, postM;
	int n,temp;
	scanf("%d", &n);
	node* root = NULL;
	for(int i=0;i<n;i++) {
		scanf("%d", &temp);
		origin.push_back(temp);
		insert(root, temp);
	}
	preorder(root, pre);
	preMorder(root, preM);
	postorder(root, post);
	postMorder(root, postM);
	if (origin == pre) {
		printf("YES\n");
		for (int i = 0; i < post.size(); i++) {
			printf("%d", post[i]);
			if (i < post.size() - 1) printf(" ");
		}
	}
	else if (origin == preM) {
		printf("YES\n");
		for (int i = 0; i < postM.size(); i++) {
			printf("%d", postM[i]);
			if (i < postM.size()-1) printf(" ");
		}
	}
	else  printf("NO\n");
	return 0;
}

A1044

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn = 100010;
int near_m = 100000010;
int diamond[maxn];
int sum[maxn];
int main() {
	int n, m;
	sum[0] = 0;
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++) {
		scanf("%d", &diamond[i]);
		sum[i] = sum[i-1]+diamond[i];
	}
	for (int i = 1; i <= n; i++) {
		int j = upper_bound(sum+i, sum+n + 1, sum[i - 1] + m)-sum;
		if (sum[j - 1] - sum[i - 1] == m) {
			near_m = m;
			break; 
		}
		else if (sum[j] - sum[i - 1] < near_m) {
			near_m = sum[j] - sum[i - 1];
		}
	}
	for (int i = 1; i <= n; i++) {
		int j= upper_bound(sum+i, sum+n + 1, sum[i-1]+near_m)-sum;
		if ( sum[j - 1] - sum[i - 1]==near_m) {
			printf("%d-%d\n", i, j - 1);
		}
	}
	return 0;
}

A1045

方法一:最长不下降子序列LIS
#include<cstdio> 
#include<algorithm>
using namespace std;
const int maxn=10010;
int hashtable[maxn],a[maxn],dp[maxn];
int main(){
	int num=0,ans=-1,n,m,L,temp;
	scanf("%d",&n);
	scanf("%d",&m);
	fill(hashtable,hashtable+maxn,-1);
	for(int i=0;i<m;i++){
		scanf("%d",&temp);
		hashtable[temp]=i;
	}
	scanf("%d",&L);
	for(int i=0;i<L;i++){
		scanf("%d",&temp);
		if(hashtable[temp]>=0){
			a[num++]=hashtable[temp];
		}
	}
	for(int i=0;i<num;i++){
		dp[i]=1;
		for(int j=0;j<i;j++){
			if(a[i]>=a[j]&&dp[j]+1>dp[i]){
				dp[i]=dp[j]+1;
			}
		}
		ans=max(ans,dp[i]);
	}
	printf("%d",ans);
	return 0;
}
方法二:最长公共子序列
#include<cstdio> 
#include<algorithm>
using namespace std;
const int maxn=10010;
int a[maxn],b[maxn],dp[maxn][maxn];
int main(){
	int n,m,L;
	scanf("%d",&n);
	scanf("%d",&m);
    for(int i=1;i<=m;i++) scanf("%d",&a[i]);
    scanf("%d",&L);
    for(int i=1;i<=L;i++) scanf("%d",&b[i]);
    for(int i=0;i<m;i++) dp[i][0]=0;
    for(int i=0;i<L;i++) dp[0][i]=0;
    for(int i=1;i<=m;i++){
    	for(int j=1;j<=L;j++){
    		int maxone=max(dp[i-1][j],dp[i][j-1]);
    		if(a[i]==b[j]) dp[i][j]=maxone+1;
    		else dp[i][j]=maxone;
		}
	}
	printf("%d",dp[m][L]);
	return 0;
}

A1046

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn = 100010;
int dis[maxn], A[maxn];
int main() {
	int n,times,left,right,sum=0;
	scanf("%d", &n);
	for (int i = 1; i <= n; i++) {
		scanf("%d", &A[i]);
		sum += A[i];
        dis[i] = sum;
	}
	scanf("%d", &times);
	for (int i = 0; i < times; i++) {
		scanf("%d%d", &left, &right);
		if (left > right)  swap(left, right);
		int distance = dis[right - 1] - dis[left - 1];
			printf("%d\n", min(distance,sum-distance));
	}
	return 0;
}

A1047

#include<cstdio>
#include<vector>
#include<algorithm>
#include<cstring>
using namespace std;
vector<int> course[2510];
char stu[40010][5];
bool cmp(int a, int  b) {  return strcmp(stu[a], stu[b]) < 0; }
int main() {
	int n,k,m;
	scanf("%d%d", &n, &k);
	for (int i = 0; i < n; i++) {
		scanf("%s", stu[i]);
		scanf("%d", &m);
		for (int j = 0; j < m; j++) {
			int id;
			scanf("%d",&id);
			course[id].push_back(i);
		}	
	}
	for (int i = 1; i <= k; i++) {
		printf("%d %d\n", i, course[i].size());
		sort(course[i].begin(), course[i].end(), cmp);
		for (int j = 0; j < course[i].size(); j++) {
			printf("%s\n", stu[course[i][j]]);
		}
	}
	return 0;
}

A1048

1.哈希散列解法
#include<cstdio>
const int maxn = 1010;
int hashtable[maxn] = { 0 };
int main() {
	int n, m;
	scanf("%d%d", &n, &m);
	for (int i = 0; i < n; i++) {
		int num;
		scanf("%d", &num);
		hashtable[num]++;
	}
	for (int i = 1; i < m; i++) {
		if (hashtable[i] > 0 && hashtable[m - i] > 0) {
			if ((i == m - i && hashtable[i] > 1) || i != m - i) {
				printf("%d %d", i, m - i);
				return 0;
			}
		}
	}
	printf("No Solution");
	return 0;
}


2.二分法解法
#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn = 100010;
int main() {
	int n, m;
	int num[maxn];
	scanf("%d%d", &n, &m);
	for (int i = 0; i < n; i++) {
		scanf("%d", &num[i]);
	}
	sort(num, num + n);
	int j,i;
	for ( i = 0; i < n; i++) {
		 j = lower_bound(num + i, num +n, m - num[i]) - num;
		if ( (num[j] + num[i] == m&&j!=i)||(num[i]==num[i+1]&&num[i]*2==m)) {
			printf("%d %d", num[i], num[j]);
			break;
		}
	}
	if (i >= n) printf("No Solution");
	return 0;
}

3.two points
#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn = 100010;
int main() {
	int n, m;
	int a[maxn];
	scanf("%d%d", &n, &m);
	for (int i = 0; i < n; i++) {
		scanf("%d", &a[i]);
	}
	sort(a, a + n);
	int j=n-1,i=0;
    while(i<j){
        if(a[i]+a[j]==m){
            printf("%d %d",a[i],a[j]);
            return 0;
        }
        else if(a[i]+a[j]>m) j--;
        else i++;
    }
	printf("No Solution");
	return 0;
}

A1049

#include <iostream>
#include<cmath>
using namespace std;
int main() {
	int n,ans=0,a=1,index=0;
	cin >> n;
	int left, now, right;
	while (n / a != 0) {
		left = n / (a * 10);
		right = n % a;
		now = n/a%10;
		if (now == 0) ans += left * pow(10, index++);
		else if(now == 1) ans += left * pow(10, index++) + 1+right;
		else ans += (left + 1) * pow(10, index++);
		a *= 10;
	}
	cout << ans;
	return 0;
}

A1050

#include<iostream>
#include<string>
using namespace std;
int main() {
	bool hashtable[128] = { false };
	string s1, s2;
	getline(cin, s1);
	getline(cin, s2);
	int len1 = s1.length();
	int len2 = s2.length();
	for (int i = 0; i < len2; i++) {
		hashtable[s2[i]] = true;
	}
	string ans;
	for (int i = 0; i < len1; i++) {
		if (hashtable[s1[i]] == false) {
			ans += s1[i];
		}
	}
	cout << ans;
	return 0;
}

A1051 栈

#include<cstdio>
#include<stack>
using namespace std;
const int maxn = 1010;
int out[maxn];
stack<int> st;
int main() {
	int m, n, k;
	scanf("%d%d%d", &m, &n, &k);
	while (k--) {
		while (!st.empty()) {
			st.pop();
		}
		bool flag=true;
		for (int i = 1; i <= n; i++) {
			scanf("%d", &out[i]);
		}
		int current = 1;
		for (int i = 1; i <= n; i++) {
			st.push(i);
			if (st.size() > m) {
				flag = false;
				break;
			}
			while(!st.empty()&&st.top() == out[current]) {
					st.pop();
					current++;
			}
		}
		if (st.empty()&& flag == true) printf("YES\n");
		else printf("NO\n");
	}
	return 0;
}

A1052(链表)

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=100010;
struct Node{
	int address,data,next;
	bool flag;
}node[maxn];
bool cmp(Node a,Node b){
	if(a.flag==false||b.flag==false) return a.flag>b.flag;
	else return a.data<b.data;
}
int main(){
	int n,begin;
	scanf("%d%d",&n,&begin);
	for(int i=0;i<maxn;i++){
		node[i].flag=false;
	}
	int address1,data1,next1;
	for(int i=0;i<n;i++){
		scanf("%d%d%d",&address1,&data1,&next1);
		node[address1].address=address1;
		node[address1].data=data1;
		node[address1].next=next1;
	}
	int p=begin,count=0;
	while(p!=-1){
		node[p].flag=true;
		count++;
		p=node[p].next;
	}
	sort(node,node+maxn,cmp);
	if(count==0) printf("0 -1");
	else{
		printf("%d %05d\n",count,node[0].address);
		for(int i=0;i<count-1;i++){
			printf("%05d %d %05d\n",node[i].address,node[i].data,node[i+1].address);
		}
		printf("%05d %d -1",node[count-1].address,node[count-1].data);
	}
	return 0;	
}

A1053

#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
const int maxn = 110;
int n, m, s;
int path[maxn];
struct node {
	int weight;
	vector<int> child;
}Node[maxn];
bool cmp(int a, int b) {
	return Node[a].weight > Node[b].weight;
}
void DFS(int index, int nodenum, int sum) {
	if (sum > s) return;
	if (sum == s) {
		if (Node[index].child.size() != 0) return;
        for (int i = 0; i < nodenum; i++) {
		     printf("%d",Node[path[i]].weight);
			 if (i < nodenum - 1) printf(" ");
			 else printf("\n");
		}
	}
	for (int i = 0; i < Node[index].child.size(); i++) {
		path[nodenum] = Node[index].child[i];
		DFS(Node[index].child[i], nodenum + 1, sum + Node[Node[index].child[i]].weight);
	}
}
int main() {
	scanf("%d%d%d", &n, &m, &s);
	for (int i = 0; i < n; i++) {
		scanf("%d", &Node[i].weight);
	}
	int father,k, temp;
	while (m--) {
		scanf("%d%d", &father,&k);
		while (k--) {
			scanf("%d", &temp);
			Node[father].child.push_back(temp);
		}
		sort(Node[father].child.begin(), Node[father].child.end(), cmp);
	}
	path[0] = 0;
	DFS(0, 1, Node[0].weight);
	return 0;
}

A1054

#include<cstdio>
#include<map>
using namespace std;
map<int, int> colors;
int main() {
	int m, n,temp;
    scanf("%d%d",&m,&n);
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < m; j++) {
            int temp;
            scanf("%d",&temp);
			if (colors.count(temp) == 0) colors[temp] = 1;
			else colors[temp]++;
		}
	}
	int ans, maxn=0;
	for (auto it = colors.begin(); it != colors.end(); it++) {
		if (it->second > maxn) {
			ans = it ->first;
			maxn = it-> second;
		}
	}
    printf("%d",ans);
	return 0;
}

A1055

#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
using namespace std;
struct node{
	char name[10];
	int age,money;
}; 
bool cmp(node a,node b){
	if(a.money!=b.money) return a.money>b.money;
	else if(a.age!=b.age) return a.age<b.age;
	else return strcmp(a.name,b.name)<0;
}
int main(){
	int n,m;
	scanf("%d%d",&n,&m);
	vector<node> total(n),elect;
	vector<int> mark(210,0);
	for(int i=0;i<n;i++) scanf("%s%d%d",total[i].name,&total[i].age,&total[i].money);
	sort(total.begin(),total.end(),cmp);
	for(int i=0;i<n;i++){
		if(mark[total[i].age]<=100){
			mark[total[i].age]++;
			elect.push_back(total[i]);
		}
	}
	int query,minage,maxage;
	for(int i=0;i<m;i++){
		scanf("%d%d%d",&query,&minage,&maxage);
		vector<node> t;
		for(int j=0;j<elect.size();j++){
			if(elect[j].age<=maxage&&elect[j].age>=minage)
				t.push_back(elect[j]);
		}
		printf("Case #%d:\n",i+1);
		int needprintf=0;
		for(int k=0;k<query&&k<t.size();k++){
			needprintf++;
		    printf("%s %d %d\n",t[k].name,t[k].age,t[k].money);
		}
		if(needprintf==0) printf("None\n");
	} 
	return 0;
}

A1056(队列)

#include<queue>
#include<cstdio>
using namespace std;
const int maxn = 1010;
struct node{
	int rank;
	int weight;
}mouse[maxn];
int main() {
    queue<int> q;
	int np, ng, order;
	scanf("%d%d", &np, &ng);
	for (int i = 0; i < np; i++) {
		scanf("%d", &mouse[i].weight);
	}
    int t=np;
	while(t--){
		scanf("%d", &order);
		q.push(order);
	}
	int temp = np, group;
	while (q.size() != 1) {
		if (temp % ng == 0) group = temp / ng;
		else group = temp / ng + 1;
		for (int i = 0; i < group; i++) {
			int k = q.front();
			for (int j = 0; j < ng; j++) {
				if (i * ng + j >= temp) break;
				int front = q.front();
				if (mouse[front].weight > mouse[k].weight) {
					k = front;
				}
				mouse[front].rank = group + 1;
				q.pop();
			}
			q.push(k);
		}
		temp = group;
	}
	mouse[q.front()].rank = 1;
	for (int i = 0; i < np; i++) {
		printf("%d", mouse[i].rank);
		if (i < np - 1) printf(" ");
	}
	return 0;
}

A1058

#include<cstdio>
int main() {
	int sum[3], m1[3], m2[3];
	int  temp_sick, temp_knut;
	scanf("%d.%d.%d", &m1[0], &m1[1], &m1[2]);
	scanf("%d.%d.%d", &m2[0], &m2[1], &m2[2]);
	sum[2] = (m1[2] + m2[2]) % 29;
	temp_knut = (m1[2] + m2[2])/ 29;
	sum[1] = (m1[1] + m2[1] + temp_knut)%17;
	temp_sick = (m1[1] + m2[1] + temp_knut) / 17;
	sum[0] = m1[0] + m2[0] + temp_sick;
	printf("%d.%d.%d", sum[0], sum[1], sum[2]);
	return 0;
}

A1059

#include<cstdio>
#include<cmath>
const int maxn = 100010;
bool isprime(int n) {
	if (n <= 1) return false;
	int sqr = sqrt(1.0 * n);
	for (int i = 2; i <= sqr; i++) {
		if (n % i == 0) return false;
	}
	return true;
}
int prime[maxn], pnum=0;
void find_prime() {
	for (int i = 1; i < maxn; i++) {
		if (isprime(i)) {
			prime[pnum++] = i;
		}
	}
}
struct factor {
	int x, exp;
}fac[10];
int main() {
	find_prime();
	int n,num=0;
	scanf("%d", &n);
	int sqr = (int)sqrt(1.0 * n);
	if (n == 1) printf("1=1");
	else {
		printf("%d=", n);
		for (int i = 0; i < pnum && prime[i] <= sqr; i++) {
			if (n % prime[i] == 0) {
				fac[num].x = prime[i];
				fac[num].exp = 0;
				while (n % prime[i] == 0) {
					fac[num].exp++;
					n /= prime[i];
				}
				num++;
			}
			if (n == 1) break;
		}
		if (n != 1) {
			fac[num].x = n;
			fac[num++].exp = 1;
		}
		for (int i = 0; i < num; i++) {
			if (i > 0) printf("*");
			printf("%d", fac[i].x);
			if (fac[i].exp > 1) printf("^%d", fac[i].exp);
		}
	}
	return 0;
}

A1060

#include<iostream> 
#include<string>
using namespace std;
int n;
string deal(string s, int& e) {
	int k = 0;
	
	while (s.length() > 0 && s[0] == '0') {
		s.erase(s.begin());
	}
	if (s[0] == '.') {
		s.erase(s.begin());
		while (s.length() > 0 && s[0] == '0') {
			s.erase(s.begin());
			e--;
		}
	}
	else {
		while (s.length() > k && s[k] != '.') {
			e++;
			k++;
		}
		if(k<s.length()) s.erase(s.begin() + k);
	}
	if (s.length() == 0) e = 0;
    string ans;
    k=0;
    int num=0;
    while(num<n){
        if(k<s.length()) ans+=s[k++];
        else ans+='0';
        num++;
    }
	return ans;
}
int main() {
	string s1, s2, ans1, ans2;
	int e1=0, e2=0;
	cin >> n >> s1 >> s2;
	ans1 = deal(s1, e1);
	ans2 = deal(s2, e2);
	if (ans1 == ans2 && e1 == e2)
		cout << "YES " << "0." << ans1 << "*10^" << e1;
	else
		cout << "NO " << "0." << ans1 << "*10^" << e1 << " " << "0." << ans2 << "*10^" << e2;
	return 0;
}

A1061

#include<cstdio>
#include<string>
#include<cstring>
using namespace std;
int main() {
	char s1[70], s2[70], s3[70], s4[70];
	string days[7] = { "MON","TUE","WED","THU","FRI","SAT","SUN" };
	scanf("%s%s%s%s", s1, s2, s3, s4);
	int len1 = strlen(s1);
	int len2 = strlen(s2);
	int len3 = strlen(s3);
	int len4 = strlen(s4);
	int i;
	for (i = 0; i < len1 && i < len2; i++) {
		if (s1[i] == s2[i] && s1[i] >= 'A' && s1[i] <= 'G') {
			printf("%s ", days[s1[i] - 'A'].c_str());
			break;
		}
	}
	for (i++; i < len2 && i < len1; i++) {
		if (s1[i] == s2[i]) {
			if (s1[i] >= '0' && s1[i] <= '9') {
				printf("%02d:", s1[i] - '0');
				break;
			}
			else if (s1[i] >= 'A' && s1[i] <= 'N') {
				printf("%02d:", s1[i] - 'A' + 10);
				break;
			}
		}
	}
	for (int j = 0; j < len3 && j < len4; j++) {
		if (s3[j] == s4[j]) {
			if ((s3[j] >= 'a' && s3[j] <= 'z') || (s3[j] >= 'A' && s3[j] <= 'Z')) {
				printf("%02d", j);
				break;
			}
		}
	}
	return 0;
}

A1062

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct test {
	char id[20];
	int de, cai, sum;
	int flag;
}student[100010];
bool cmp(test a, test b) {
	if (a.flag != b.flag) return a.flag < b.flag;
	else if (a.sum != b.sum) return a.sum > b.sum;
	else if (a.de != b.de) return a.de > b.de;
	else return strcmp(a.id, b.id) < 0;
}
int main() {
	int total, low, high;
	scanf("%d%d%d", &total, &low, &high);
	int pass = total;
	for (int i = 0; i < total; i++) {
		scanf("%s%d%d", student[i].id, &student[i].de, &student[i].cai);
		student[i].sum = student[i].de + student[i].cai;
		if (student[i].de < low || student[i].cai < low) {
			student[i].flag = 5;
			pass--;
		}
		else if (student[i].cai >= high && student[i].de >= high) student[i].flag = 1;
		else if (student[i].cai >= low && student[i].cai < high && student[i].de >= high) student[i].flag = 2;
		else if (student[i].cai >= low && student[i].cai <= student[i].de && student[i].de<high) student[i].flag = 3;
		else  student[i].flag = 4;
	}
	sort(student, student + total, cmp);
	printf("%d\n", pass);
	for (int i = 0; i < pass; i++) {
		printf("%s %d %d\n", student[i].id, student[i].de, student[i].cai);
	}
	return 0;
}

A1063

#include<cstdio>
#include<set>
using namespace std;
const int maxn = 51;
set<int> v[maxn];
int main() {
	int n,m,temp,k;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &m);
		for (int j = 0; j < m; j++) {
			scanf("%d", &temp);
			v[i].insert(temp);
		}
	}
	int a, b;
	scanf("%d", &k);
	for (int i = 0; i < k; i++) {
		scanf("%d%d", &a, &b);
		int nc=0, nt=v[b-1].size();
		for (auto it = v[a - 1].begin(); it != v[a - 1].end(); it++) {
			if (v[b - 1].find(*it) != v[b - 1].end())  nc++;
			else nt++;
		}
		printf("%.1f%%\n", (nc * 100.0) / nt);
	}
}

A1064

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn = 1010;
int CBT[maxn],index=0,number[maxn],n;
void inorder(int root) {
	if (root > n) return;
	inorder(root * 2);
	CBT[root] = number[index++];
	inorder(root * 2 + 1);
}
int main() {
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &number[i]);
	}
	sort(number, number + n);
	inorder(1);
	for (int i = 1; i <= n; i++) {
		printf("%d", CBT[i]);
		if (i < n) printf(" ");
	}
	return 0;
}

A1065

#include<cstdio>
int main() {
	long long a, b, c;
	int n,times=1;
	scanf("%d", &n);
	while (n--) {
		scanf("%lld%lld%lld", &a, &b, &c);
		bool flag;
		long long sum = a + b;
		if (a > 0 && b > 0 && sum < 0)
			flag = true;
		else if (a < 0 && b < 0 && sum >= 0)
			flag = false;
		else if (sum > c)
			flag = true;
		else flag = false;
		if (flag == true)
			printf("Case #%d:true", times++);
		if (flag == false)
			printf("Case #%d:false", times++);
	}
	return 0;
}

A1066

#include<cstdio>
#include<algorithm>
using namespace std;
struct node {
	int v, height;
	node* lchild, *rchild;
};
node* newNode(int v) {
	node* Node = new node;
	Node->v = v;
	Node->height = 1;
	Node->lchild = Node->rchild = NULL;
	return Node;
}
int getheight(node* root) {
	if (root == NULL) return 0;
	return root->height;
}
void updateheight(node* root) {
	root->height = max(getheight(root->lchild), getheight(root->rchild)) + 1;
}
int getbalancefactor(node* root) {
	return getheight(root->lchild) - getheight(root->rchild);
}
void L(node*& root) {
	node* temp = root->rchild;
	root->rchild = temp->lchild;
	temp->lchild = root;
	updateheight(root);
	updateheight(temp);
	root = temp;
}
void R(node*& root) {
	node* temp = root->lchild;
	root->lchild = temp->rchild;
	temp->rchild = root;
	updateheight(root);
	updateheight(temp);
	root = temp;
}
void insert(node*& root, int v) {
	if (root == NULL) {
		root = newNode(v);
		return ;
	}
	if (v < root->v) {
		insert(root->lchild, v);
		updateheight(root);
		if (getbalancefactor(root) == 2) {
			if (getbalancefactor(root->lchild) == 1) {
				R(root);
			}
			else if (getbalancefactor(root->lchild) == -1) {
				L(root->lchild);
				R(root);
			}
		}
	}
	else {
		insert(root->rchild,v);
		updateheight(root);
		if (getbalancefactor(root) == -2) {
			if (getbalancefactor(root->rchild) == -1) {
				L(root);
			}
			else if (getbalancefactor(root->rchild) == 1) {
				R(root->rchild);
				L(root);
			}
		}
	}
}
int main() {
	int n, v;
	scanf("%d", &n);
	node* root =NULL;
	for (int i = 0; i < n; i++) {
		scanf("%d", &v);
		insert(root, v);
	}
	printf("%d", root->v);
	return 0;
}

A1067

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn = 100010;
int main() {
	int n,p[maxn],ans=0;
	scanf("%d", &n);
	int left = n - 1;
	for (int i = 0; i < n; i++) {
		int num;
		scanf("%d", &num);
		p[num] = i;
		if(num != 0 && p[num] == num) {
			left--;
		}
	}
	int k = 1;
	while (left > 0) {
		if (p[0] == 0) {
			while (k<n) {
				if (p[k] != k) {
					swap(p[0], p[k]);
					ans++;
					break;
				}
				k++;
			}
		}
		while(p[0]!=0) {
			swap(p[p[0]], p[0]);
			ans++;
			left--;
		}
	}
	printf("%d", ans);
	return 0;
}

A1068

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=10010;
const int maxv=110;
int dp[maxv]={0},w[maxn];
bool choice[maxn][maxv],flag[maxn];
bool cmp(int a,int b){
	return a>b;
}
int main(){
	int n,m;
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++){
		scanf("%d",&w[i]);
	}
	sort(w+1,w+1+n,cmp);
	for(int i=1;i<=n;i++){
		for(int v=m;v>=w[i];v--){
			if(dp[v]<=dp[v-w[i]]+w[i]){
				dp[v]=dp[v-w[i]]+w[i];
				choice[i][v]=1;
			}else{
				choice[i][v]=0;
			}
		}
	}
	if(dp[m]!=m) printf("No Solution");
	else{
		int k=n,num=0,v=m;
		while(k>=0){
			if(choice[k][v]==1){
				flag[k]=true;
				v-=w[k];
				num++;
			}else flag[k]=false;
			k--;
		}
		for(int i=n;i>0;i--){
			if(flag[i]==true){
				printf("%d",w[i]);
				num--;
				if(num>0) printf(" ");
			}
		}
	}
	return 0;
}

A1069

#include<cstdio>
#include<algorithm>
#include<string>
using namespace std;
bool cmp(int a, int b) {
	return a > b;
}
int a[4];
int to_number(int a[]) {
	int res = a[0] * 1000 + a[1] * 100 + a[2] * 10 + a[3] * 1;
	return res;
}
void to_arry(int num) {
	for (int j = 0; j < 4; j++) {
		a[j] = num % 10;
		num = num / 10;
	}
}
int main() {
	int big, small, ans;
	scanf("%d", &ans);
	do {
		to_arry(ans);
		sort(a, a + 4);
		small = to_number(a);
		sort(a, a + 4, cmp);
		big = to_number(a);
		ans = big - small;
		printf("%04d - %04d = %04d\n", big, small, ans);
		
	} while (ans > 0 && ans != 6174);
	return 0;
}

A1070

#include<cstdio>
#include<algorithm>
using namespace std;
struct node {
	double price;
	double stock;
}mooncake[1001];
bool cmp(node a, node b) {
	return a.price/a.stock > b.price/b.stock;
}
int main() {
	int n, d;
	scanf("%d%d", &n, &d);
	for (int i = 0; i < n; i++) {
		double stock;
		scanf("%lf", &stock);
		mooncake[i].stock = stock;
	}
	for (int i = 0; i < n; i++) {
		double price;
		scanf("%lf", &price);
		mooncake[i].price = price;
	}
	sort(mooncake, mooncake + n, cmp);
	double nowneed = (double)d;
	double income = 0.0;
	for (int i = 0; i < n; i++) {
		if (mooncake[i].stock >= nowneed) {
			income =income+(mooncake[i].price/mooncake[i].stock)*nowneed;
			nowneed = 0;
			break;
		}
		else {
			nowneed -= mooncake[i].stock;
			income += mooncake[i].price;
		}
	}
	printf("%.2f", income);
	return 0;
}

A1071

#include<iostream>
#include<map>
#include<string>
using namespace std;
bool check(char a) {
	if (a >= '0' && a <= '9') return true;
	if (a >= 'a' && a <= 'z') return true;
	if (a >= 'A' && a <= 'Z') return true;
	return false;
}
map<string, int> text;
int main() {
	string str;
	getline(cin, str);
	int len = str.size();
	int i = 0;
	string ans,result;
	while (i < len) {
		if (check(str[i])) {
			if (str[i] >= 'A' && str[i] <= 'Z') {
				str[i] += 32;
			}
			ans += str[i];
			if (check(str[i + 1]) == false || i + 1 == len) {
				if (text.count(ans) == 0) text[ans] = 1;
				else text[ans]++;
				ans.clear();
			}
		}
		i++;
	}
	int maxtimes = 0;
	for (auto it = text.begin(); it != text.end(); it++) {
		if (it->second > maxtimes) {
			result = it->first;
			maxtimes = it->second;
		}
	}
	cout << result << " " << maxtimes;
	return 0;
}

A1072

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
const int maxn=1016;
const int INF=1000000000;
bool vis[maxn]={false};
int n,m,k,ds,G[maxn][maxn],d[maxn];
void dijkst(int s){
	fill(d,d+maxn,INF);
	fill(vis,vis+maxn,false);
	d[s]=0;
    for(int i=1;i<=n+m;i++){
    	int u=-1,MIN=INF;
    	for(int j=1;j<=n+m;j++){
    		if(vis[j]==false&&d[j]<MIN){
    			u=j;
			    MIN=d[u];
			}
		}
		if(u==-1) return;
		vis[u]=true;
		for(int v=1;v<=n+m;v++){
			if(vis[v]==false&&G[u][v]!=INF){
				if(d[v]>d[u]+G[u][v]){
					d[v]=d[u]+G[u][v];
				}
			}
		}
	}	
}
int getid(char str[]){
	int i=0,len=strlen(str),id=0;
	while(i<len){
		if(str[i]!='G'){
			id=id*10+(str[i]-'0');
		}
		i++;
	}
	if(str[0]=='G') return id+n;
	else return id;
}
int main(){
	scanf("%d%d%d%d",&n,&m,&k,&ds);
	fill(G[0],G[0]+maxn*maxn,INF);
	for(int i=0;i<k;i++){
		char str1[6],str2[6];
		int distance,id1,id2;;
		scanf("%s %s %d",str1,str2,&distance);
		id1=getid(str1);
		id2=getid(str2);
		G[id1][id2]=distance;
		G[id2][id1]=G[id1][id2];
	}
	double ansavg=INF,ansdis=-1;
	vector<int> ansid;
	for(int i=n+1;i<=n+m;i++){
		dijkst(i);
		double mindis=INF,avgdis=0.0;
		int j;
		for(j=1;j<=n;j++){
			if(d[j]>ds) break;
			if(d[j]<mindis){
				mindis=d[j];
			}
			avgdis+=d[j]*1.0/n;
		}
		if(j<n+1) continue;
		if(mindis>ansdis){
			ansdis=mindis;
			ansavg=avgdis;
			ansid.clear();
			ansid.push_back(i);
		}else if(mindis==ansdis){
			if(ansavg>avgdis){
				ansavg=avgdis;
				ansid.clear();
			    ansid.push_back(i);
			} 
			else if(ansavg==avgdis) ansid.push_back(i);
		}
	}
	if(ansid.size()==0) printf("No Solution");
	else{
		printf("G%d\n",ansid[0]-n);
		printf("%.1f %.1f",ansdis,ansavg);
	}
	return 0;
}

A1073 科学计数法

#include<cstdio> 
#include<cstring>
int main(){
	char str[10010];
	scanf("%s",str);
	int len=strlen(str);
	int pos=0;
	while(str[pos]!='E') pos++;
	if(str[0]=='-') printf("-");
	int exp=0;
	for(int i=pos+2;i<len;i++){
		exp=exp*10+str[i]-'0';
	}
	if(exp==0){
		for(int i=1;i<pos;i++){
			printf("%c",str[i]);
		}
	}
	if(str[pos+1]=='-'){
		printf("0.");
		for(int t=0;t<exp-1;t++) printf("0");
		for(int j=1;j<pos;j++){
			if(str[j]=='.') continue;
			printf("%c",str[j]);
		}
	}
	else{
		for(int i=1;i<pos;i++){
			if(str[i]=='.') continue;
			printf("%c",str[i]);
			if(i==exp+2&&(pos-3)!=exp){
				printf(".");
			}
		}
		for(int k=0;k<exp-(pos-3);k++) printf("0");
	} 
	return 0;
}

A1074(链表)

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn = 100010;
struct Node {
	int address, data, next;
	int order;
}node[maxn];
bool cmp(Node a, Node b) {
	return a.order < b.order;
}
int main() {
	for (int i = 0; i < maxn; i++) {
		node[i].order = maxn;
	}
	int begin, n, k,count=0;
	scanf("%d%d%d", &begin, &n, &k);
	for (int i = 0; i < n; i++) {
		int address;
		scanf("%d", &address);
		scanf("%d%d", &node[address].data, &node[address].next);
		node[address].address = address;
	}
	int p = begin;
	while (p != -1) {
		node[p].order = count++;
		p = node[p].next;
	}
	sort(node, node + maxn, cmp);
	for (int i = 0; i < count / k; i++) {
		for (int j = (i + 1) * k - 1; j > i * k; j--) {
			printf("%05d %d %05d\n", node[j].address, node[j].data, node[j - 1].address);
		}
		printf("%05d %d ", node[i * k].address, node[i * k].data);
		if (i < count / k - 1) {
			node[i * k].next = node[(i + 2) * k - 1].address;
			printf("%05d\n", node[i * k].next);
		}
		else {
			if (count % k == 0) {
				printf("-1\n");
			}
			else {
				node[i * k].next = node[(i + 1) * k ].address;
				printf("%05d\n", node[i * k].next);
				if(count==(i+1)*k+1) printf("%05d %d -1\n", node[count - 1].address, node[count - 1].data);
				else {
					for (int x = (i + 1) * k; x < count-1; x++) {
						printf("%05d %d %05d\n", node[x].address, node[x].data, node[x + 1].address);
					}
					printf("%05d %d -1\n", node[count - 1].address, node[count - 1].data);
				}
				
			}
		}
	}
	return 0;
}

A1075

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn = 10010;
struct node {
	int rank;
	int id;
	int score[6];
	int total;
	int perfect;
	bool canprint;
}user[maxn];
bool cmp(node a, node b) {
	if (a.canprint == false || b.canprint == false) return a.canprint > b.canprint;
	else if (a.total != b.total) return a.total > b.total;
	else if (a.perfect != b.perfect) return a.perfect > b.perfect;
	else return a.id < b.id;
}
int main() {
	int n, k, m, question[6] = { 0 };
	scanf_s("%d%d%d", &n, &k, &m);
	for (int i = 1; i <= k; i++) scanf_s("%d", &question[i]);
	for (int i = 0; i < maxn; i++) {
		memset(user[i].score, -1, sizeof(user[i].score));
		user[i].total = 0;
		user[i].perfect = 0;
		user[i].canprint = false;
	}
	for (int i = 0; i < m; i++) {
		int id,problem_id,score;
		scanf_s("%d %d %d", &id,&problem_id,&score);
		user[id].id = id;
		if (score == -1&&user[id].score[problem_id]==-1) user[id].score[problem_id] = 0;//第一次未能编译通过
		if (score != -1) {
			user[id].canprint = true;
			if (score == question[problem_id]&&user[id].score[problem_id]<question[problem_id]) user[id].perfect++;
		}
		if (score >= user[id].score[problem_id]) user[id].score[problem_id] = score;//第一次满分
	}
	for (int i = 0; i < maxn; i++) {
		for (int j = 1; j <= k; j++) {
			if (user[i].score[j] != -1) {
				user[i].total += user[i].score[j];
			}
		}
	}
	sort(user, user + maxn, cmp);
	user[0].rank = 1;
	for (int j = 1; j < n; j++) {
		if (user[j].total == user[j - 1].total) {
			user[j].rank = user[j - 1].rank;
		}
		else user[j].rank = j + 1;
	}
	for (int i = 0; i < n; i++) {
		if (user[i].canprint == true) {
			printf("%d %05d %d", user[i].rank, user[i].id, user[i].total);
			for (int j = 1; j <= k; j++) {
				if (user[i].score[j] == -1) printf(" -");
				else {
					printf(" %d", user[i].score[j]);
				}
			}
			printf("\n");
		}
	}
	return 0;
}

A1076

#include<cstdio>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
const int maxn=1010;
bool inq[maxn]={false};
struct node{
	int id;
	int layer;
};
vector<node> adj[maxn];
int BFS(int s,int L){
	int numforward=0;
	queue<node> q;
	node start;
	start.id=s;
	start.layer=0;
	q.push(start);
	inq[start.id]=true;
	while(!q.empty()){
		node now;
		now.id=q.front().id;
		now.layer=q.front().layer;
		q.pop();
		for(int i=0;i<adj[now.id].size();i++){
			node next=adj[now.id][i];
			next.layer=now.layer+1;
			if(inq[next.id]==false&&next.layer<=L){
				q.push(next);
				inq[next.id]=true;
				numforward++;
			}
		}
	}
	return numforward;
}
int main(){
	int n,L,followid,m,k,userid,numforward=0;
	scanf("%d%d",&n,&L);
	for(int i=1;i<=n;i++){
		node user;
		user.id=i;
		scanf("%d",&m);
		while(m--){
			scanf("%d",&followid);
			adj[followid].push_back(user);
		}
	}
	scanf("%d",&k);
	while(k--){
		scanf("%d",&userid);
		fill(inq,inq+maxn,false);
		numforward=BFS(userid,L);
		printf("%d\n",numforward);
	}
	return 0;
}

A1078

#include<cstdio>
#include<cmath>
bool isprime(int n) {
	if (n <= 1) return false;
	int sqr = sqrt(1.0 * n);
	for (int i = 2; i <= sqr; i++) {
		if (n % i == 0) return false;
	}
	return true;
}
bool hashtable[100010] = { 0 };
int main() {
	int tsize, n, a;
	scanf("%d%d", &tsize, &n);
    while(!isprime(tsize)){
        tsize++;
    }
	for (int i = 0; i < n; i++) {
		scanf("%d", &a);
		int m = a % tsize;
		if (hashtable[m] == false) {
			hashtable[m] = true;
			if (i == 0) printf("%d", m);
			else printf(" %d", m);
		}
		else {
            int step;
			for (step = 1; step < tsize; step++) {
                m=(a+step*step)%tsize;
				if (hashtable[m] == false) {
					hashtable[m] =true;
					printf(" %d",m);
					break;
				}
			}
			if (step == tsize) {
				printf(" -");
			}
		}
	}
	return 0;
}

A1079

#include<cstdio>
#include<cmath>
#include<vector>
using namespace std;
const int maxn=100010;
struct node{
	int data;
	vector<int>child;
}Node[maxn];
double p,r,ans=0;
int n;
void DFS(int index,int depth){
	if(Node[index].child.size()==0){
		ans+=Node[index].data*p*pow((1+r/100),depth);
		return;
	}
	for(int i=0;i<Node[index].child.size();i++){
		DFS(Node[index].child[i],depth+1);
	}
}
int main(){
	int num;
	scanf("%d%lf%lf",&n,&p,&r);
	for(int i=0;i<n;i++){
		int temp;
		scanf("%d",&num);
		if(num==0){
			scanf("%d",&temp);
			Node[i].data=temp;
		}else{
			for(int j=0;j<num;j++){
				scanf("%d",&temp);
				Node[i].child.push_back(temp);
			}
		}	
	}
	DFS(0,0);
	printf("%.1f",ans);
	return 0;
}

A1080

#include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;
const int maxn = 40010;
struct node {
	int rank;
	int GE, GI,fgrade;
	int id;
	int choice[6];
}app[maxn];
struct node1 {
	int num;
	int quota;
	int id[maxn];
	int lastadmit;
}sch[110];
bool cmpapp(node a, node b) {
	if (a.fgrade != b.fgrade) return a.fgrade > b.fgrade;
	else return a.GE > b.GE;
}
bool cmpstu(int a,int b) {
	return app[a].id < app[b].id;
}
int main() {
	int n, m, k;
	scanf("%d%d%d", &n, &m, &k);
	for (int i = 0; i < m; i++) {
		scanf("%d", &sch[i].quota);
		sch[i].num = 0;
		sch[i].lastadmit = -1;
	}
	for (int i = 0; i < n; i++) {
		scanf("%d%d", &app[i].GE, &app[i].GI);
		app[i].id = i;
		for (int j = 0; j < k; j++) {
			scanf("%d", &app[i].choice[j]);
		}
		app[i].fgrade = app[i].GE + app[i].GI;
	}
	sort(app, app + n, cmpapp);
	for (int i = 0; i < n; i++) {
		if (i > 0 && (app[i].fgrade == app[i - 1].fgrade) && (app[i].GE == app[i - 1].GE)) {
			app[i].rank = app[i - 1].rank;
		}
		else {
			app[i].rank = i;
		}
	}
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < k; j++) {
			int choice = app[i].choice[j];
			int num = sch[choice].num;
			int last = sch[choice].lastadmit;
			if (sch[choice].quota > num || (last != -1 && app[i].rank == app[last].rank)) {
				sch[choice].id[num] = i;
				sch[choice].num++;
				sch[choice].lastadmit = i;
				break;
			}
		}
	}
	for (int i = 0; i < m; i++) {
		if (sch[i].num > 0) {
			sort(sch[i].id, sch[i].id + sch[i].num, cmpstu);
			for (int j = 0; j < sch[i].num; j++) {
				printf("%d", app[sch[i].id[j]].id);
				if (j < sch[i].num - 1) {
					printf(" ");
				}
			}
		}
		printf("\n");
	}
	return 0;
}

A1081

#include<cstdio>
long long gcd(int a, int b) {
	return b == 0 ? a : gcd(b, a % b);
}
int main() {
	int n;
	scanf("%d", &n);
	long long a2 = 0, b2 = 1,gcdvalue;
	for (int i = 0; i < n; i++) {
		long long a, b;
		scanf("%lld/%lld", &a, &b);
		gcdvalue = gcd(a, b);
		a /= gcdvalue;
		b /= gcdvalue;
		a2 = a * b2 + b * a2;
		b2 = b * b2;
		gcdvalue = gcd(a2, b2);
		a2 /= gcdvalue;
		b2 /= gcdvalue;
	}
	long long integer = a2 / b2;
	a2 = a2 - integer * b2;
	if (integer != 0) {
		printf("%lld", integer);
		if (a2 > 0) printf(" %lld/%lld",a2,b2);
		else if (a2 < 0) printf(" %lld/%lld", -a2, b2);
	}
	if (integer == 0 && a2 != 0) printf("%lld/%lld", a2, b2);
	if (integer == 0 && a2 == 0) printf("0");
	return 0;
}

A1082

#include<iostream>
#include<string>
using namespace std;
string num[10] = { "ling","yi","er","san","si","wu","liu","qi","ba","jiu" };
string wei[5] = { "Shi","Bai","Qian","Wan","Yi" };
int main() {
	string str;
	getline(cin, str);
	int len = str.length();
	int left = 0, right = len - 1;
	if (str[0] == '-') {
		cout << "Fu";
		left++;
	}
	while (left + 4 <= right) {
		right -= 4;
	}
	while (left < len) {
		bool flag = false;
		bool hasprint = false;
		while (left <= right) {
			if (str[left] == '0' && left > 0) {
				flag = true;
			}
			else {
				if (flag == true) {
					cout << " ling";
					flag = false;
				}
				if (left>=1) cout << " ";
				cout << num[str[left] - '0'];
				hasprint = true;
				if(left!=right) cout<<" "<< wei[right - left - 1];
			}
			left++;
		}
		if (hasprint == true && left <len ) {
			cout << " " << wei[(len - left) / 4 + 2];
		}
		right += 4;
	}
	return 0;
}

A1083

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn = 100010;
struct node {
	char name[12];
	char id[12];
	int score;
}stu[maxn];
bool cmp(node a, node b) {
	return a.score > b.score;
}
int main() {
	int n,grade1,grade2;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%s%s%d", stu[i].name, stu[i].id, &stu[i].score);
	}
	scanf("%d%d", &grade1, &grade2);
	sort(stu, stu + n, cmp);
	bool canprint = false;
	for (int i = 0; i < n; i++) {
		if (stu[i].score >= grade1 && stu[i].score <= grade2) {
			canprint = true;
			printf("%s %s\n", stu[i].name, stu[i].id);
		}
	}
	if (canprint == false) printf("NONE");
	return 0;
}

A1084

#include<iostream>
#include<string>
using namespace std;
bool hashtable[128] = { false };
int main() {
	string str1,str2;
	getline(cin, str1);
	getline(cin, str2);
	int len1 = str1.length();
	int len2 = str2.length();
	for (int i = 0; i < len1; i++) {
		int j;
		if (str1[i] >= 'a' && str1[i] <= 'z') str1[i] -= 32;
		for (j = 0; j < len2; j++) {
			if ((str1[i] >= '0' && str1[i] <= '9') || str1[i] == '_') {
				if (str2[j] == str1[i]){
					break;
				}
			}
			else {
				if (str2[j] >= 'a' && str2[j] <= 'z') str2[j] -= 32;
				if (str1[i] == str2[j]) break;
			}
		}
		if (j == len2 && hashtable[str1[i]] == false) {
			hashtable[str1[i]] = true;
			printf("%c", str1[i]);
		}
	}
	return 0;
}

A1085

二分法
#include<algorithm>
#include<cstdio>
using namespace std;
const int maxn = 100010;
int main() {
	int n, p,num[maxn];
	scanf("%d%d", &n, &p);
	for (int i = 0; i < n; i++) {
		scanf("%d", &num[i]);
	}
	sort(num,num + n);
	int ans = 0;
	for (int i = 0; i < n; i++) {
        long long k=(long long)p*num[i];
		int* right=upper_bound(num+i+1, num+n, k);
        int j=right-num;
		ans = max(ans, j-i);
	}
	printf("%d", ans);
	return 0; 
}

two points
#include<algorithm>
#include<cstdio>
using namespace std;
const int maxn = 100010;
int main() {
	int n, p,num[maxn];
	scanf("%d%d", &n, &p);
	for (int i = 0; i < n; i++) {
		scanf("%d", &num[i]);
	}
	sort(num,num + n);
	int count=0,i=0,j=0;
    while(i<n&&j<n){
        while(j<n&&num[j]<=(long long)num[i]*p){
            count=max(count,j-i+1);
            j++;
        }
        i++;
    }
    printf("%d",count);
    return 0;
}

A1086

#include<cstdio>
#include<cstring>
#include<stack>
#include<algorithm>
using namespace std;
const int maxn = 50;
struct node {
	int data;
	node* lchild;
	node* rchild;
};
int  pre[maxn], in1[maxn];
int n;
node* create(int preL, int preR, int inL, int inR) {
	if (preL > preR) return NULL;
	node* root = new node;
	root->data = pre[preL];
	int k;
	for (k = inL; k < inR; k++) {
		if (in1[k] == pre[preL]) {
			break;
		}
	}
	int numleft = k - inL;
	root->lchild = create(preL + 1, preL + numleft, inL, k - 1);
	root->rchild = create(preL + numleft + 1, preR, k + 1, inR);
	return root;
}
int num=0;
void postorder(node* root) {
	if (root == NULL) return;
	postorder(root->lchild);
	postorder(root->rchild);
	printf("%d", root->data);
	num++;
	if (num < n) printf(" ");
}
int main() {
	scanf("%d", &n);
	char str[5];
	stack<int> st;
	int preindex = 0, inindex = 0, x;
	for (int i = 0; i <2*n; i++) {
		scanf("%s", str);
		if (strcmp(str,"Push")==0) {
			scanf("%d", &x);
			pre[preindex++] = x;
			st.push(x);
		}
		else {
			in1[inindex++] = st.top();
			st.pop();
		}
	}
	node* root = create(0, n - 1, 0, n - 1);
	postorder(root);
	return 0;
}

A1087

#include<iostream>
#include<algorithm>
#include<string>
#include<map>
using namespace std;
const int maxn=210;
const int INF=1000000000;
int pre[maxn],num[maxn],d[maxn],w[maxn],weight[maxn],pt[maxn],G[maxn][maxn];
int n,k;
bool vis[maxn];
map<int,string> inttostring;
map<string,int> stringtoint;
void dijkst(int s){
	fill(vis,vis+maxn,false);
	fill(d,d+maxn,INF);
	fill(w,w+maxn,0);
	fill(pt,pt+maxn,0);
	fill(num,num+maxn,0);
    for(int i=0;i<n;i++) pre[i]=i;
	d[s]=0;
	w[s]=weight[s];
	num[s]=1;
	for(int i=0;i<n;i++){
		int u=-1,MIN=INF;
		for(int j=0;j<n;j++){
			if(vis[j]==false&&d[j]<MIN){
				u=j;
				MIN=d[u];
			}
		}
		if(u==-1) return;
		vis[u]=true;
		for(int v=0;v<n;v++){
			if(vis[v]==false&&G[u][v]!=INF){
				if(d[v]>d[u]+G[u][v]){
					d[v]=d[u]+G[u][v];
					w[v]=w[u]+weight[v];	
					num[v]=num[u];
					pt[v]=pt[u]+1;
					pre[v]=u;
				}else if(d[v]==d[u]+G[u][v]){
					num[v]+=num[u];
					if(w[v]<w[u]+weight[v]){
						w[v]=w[u]+weight[v];
						pt[v]=pt[u]+1;
						pre[v]=u;
					}else if(w[v]==weight[v]+w[u]){
						double avgfun1=w[v]*1.0/pt[v];
						double avgfun2=(weight[v]+w[u])*1.0/(pt[u]+1);
						if(avgfun2>avgfun1){
							pt[v]=pt[u]+1;
							pre[v]=u;
						}
					}
				}
			}
		}
	}
}
void printpath(int v){
	if(v==0){
		cout<<inttostring[v];
		return;
	}
	printpath(pre[v]);
	cout<<"->"<<inttostring[v];
}
int main(){
	string begincity,tempcity,c1,c2;
	cin>>n>>k>>begincity;
	stringtoint[begincity]=0;
	inttostring[0]=begincity;
	fill(G[0],G[0]+maxn*maxn,INF);
	for(int i=1;i<=n-1;i++){
		cin>>tempcity>>weight[i];
		stringtoint[tempcity]=i;
		inttostring[i]=tempcity;
	}
	for(int i=0;i<k;i++){
		cin>>c1>>c2;
		int id1=stringtoint[c1];
		int id2=stringtoint[c2];
		cin>>G[id1][id2];
		G[id2][id1]=G[id1][id2];
	}
	dijkst(0);
	int end=stringtoint["ROM"];
	printf("%d %d %d %d\n",num[end],d[end],w[end],w[end]/pt[end]);
    printpath(end);
    return 0;
}

A1088

#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
ll gcd(ll a, ll b) {
	return b == 0 ? a : gcd(b, a % b);
}
struct fraction {
	ll up, down;
}a, b;
fraction reduction(fraction result) {
	if (result.down < 0) {
		result.up = -result.up;
		result.down = -result.down;
	}
	if (result.up == 0) result.down = 1;
	else {
		ll gcdvalue = gcd(abs(result.up), abs(result.down));
		result.up /= gcdvalue;
		result.down /= gcdvalue;
	}
	return result;
}
fraction add(fraction f1, fraction f2) {
	fraction result;
	result.up = f1.up * f2.down + f1.down * f2.up;
	result.down = f1.down * f2.down;
	return reduction(result);
}
fraction subtract(fraction f1, fraction f2) {
	fraction result;
	result.up = f1.up * f2.down - f1.down * f2.up;
	result.down = f1.down * f2.down;
	return reduction(result);
}
fraction multi(fraction f1, fraction f2) {
	fraction result;
	result.up = f1.up * f2.up;
	result.down = f1.down * f2.down;
	return reduction(result);
}
fraction divide(fraction f1, fraction f2) {
	fraction result;
	result.up = f1.up * f2.down;
	result.down = f1.down * f2.up;
	return reduction(result);
}
void showresult(fraction r) {
	r = reduction(r);
	if (r.up < 0) printf("(");
	if (r.down == 1) printf("%lld", r.up);
	else if (abs(r.up) < r.down) printf("%lld/%lld", r.up, r.down);
	else if (abs(r.up) > r.down) printf("%lld %lld/%lld", r.up / r.down, abs(r.up) % r.down, r.down);
	if (r.up < 0) printf(")");
}
int main() {
	scanf("%lld/%lld %lld/%lld", &a.up, &a.down, &b.up, &b.down);
	showresult(a);
	printf(" + ");
	showresult(b);
	printf(" = ");
	showresult(add(a, b));
	printf("\n");
	showresult(a);
	printf(" - ");
	showresult(b);
	printf(" = ");
	showresult(subtract(a, b));
	printf("\n");
	showresult(a);
	printf(" * ");
	showresult(b);
	printf(" = ");
	showresult(multi(a, b));
	printf("\n");
	showresult(a);
	printf(" / ");
	showresult(b);
	printf(" = ");
	if (b.up == 0) printf("Inf");
	else showresult(divide(a, b));
	return 0;
}

A1089 TWO POINTS

#include<iostream>
#include<algorithm>
using namespace std;
int main() {
	int a[100], b[100];
	int n,i,j;
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> a[i];
	}
	for (int i = 0; i < n; i++) {
		cin >>b[i];
	}
	for ( i = 0; b[i] <= b[i + 1] && i < n-1; i++);
	for (j = i + 1; a[j] == b[j] && j < n; j++);
	if (j == n) {
		cout << "Insertion Sort" << endl;
		sort(a, a + i + 2);
	}
	else {
		cout << "Merge Sort" << endl;
		int k = 1;
		bool flag = true;
		while (flag) {
			flag = false;
			for (int k = 0; k < n; k++) {
				if (a[k] != b[k]) {
					flag = true;
				}
			}
			k = k * 2;
			for (i = 0; i < n / k; i++) {
				sort(a + i * k, a + i * k + k);
			}
			sort(a + n / k * k, a + n);
		}
	}
    cout<<a[0];
	for (int i = 1; i < n; i++) {
		cout<<" " << a[i];
	}
	return 0;
}

A1090

#include<cstdio>
#include<vector>
#include<cmath>
using namespace std;
const int maxn=100010;
vector<int> children[maxn];
int maxdepth=0,num=0;
void DFS(int index,int depth){
	if(children[index].size()==0){
		if(depth>maxdepth){
			maxdepth=depth;
			num=1;
		}
		else if(depth==maxdepth){
			num++;
		}
		return;
	}
	for(int i=0;i<children[index].size();i++){
		DFS(children[index][i],depth+1);
	}
}
int main(){
	int n,father,root;
	double p,r;
	scanf("%d",&n);
	scanf("%lf%lf",&p,&r);
	r/=100;
	for(int i=0;i<n;i++){
		scanf("%d",&father);
		if(father!=-1){
			children[father].push_back(i);
		}
		else root=i;
	}
	DFS(root,0);
	printf("%.2f %d",p*pow((1+r),maxdepth),num);
	return 0;
}

A1091

#include<cstdio>
#include<queue>
using namespace std;
int m, n, slice,T;
struct node {
	int x, y, z;
}Node;
int pixel[61][1290][128] = { 0 };
bool inq[61][1290][128] = { false };
int Y[6] = { 0,0,0,0,-1,1 };
int X[6] = { 0,0,1,-1,0,0 };
int Z[6] = { 1,-1,0,0,0,0 };
bool judge(int z, int x, int y) {
	if (z >= slice || z < 0 || x >= m || x < 0 || y >= n || y < 0) {
		return false;
	}
	if (inq[z][x][y]==true||pixel[z][x][y]==0) {
		return false;
	}
	return true;
}
int BFS(int z,int x,int y){
	int total=0;
	Node.x = x;
	Node.y = y;
	Node.z = z;
	inq[z][x][y] = true;
	queue<node> q;
	q.push(Node);
	while (!q.empty()) {
		node topp = q.front();
		q.pop();
		total++;
		int newx, newy, newz;
		for (int i = 0; i < 6; i++) {
			newz = topp.z + Z[i];
			newx = topp.x + X[i];
			newy = topp.y + Y[i];
			if (judge(newz, newx, newy)) {
				Node.x = newx;
				Node.y = newy;
				Node.z = newz;
				q.push(Node);
				inq[Node.z][Node.x][Node.y] = true;
			}
		}
	}
	if (total >= T) return total;
	else return 0;
}
int main() {
	int ans = 0;
	scanf("%d%d%d%d", &m, &n, &slice, &T);
	for (int i = 0; i < slice; i++) {
		for (int j = 0; j < m; j++) {
			for (int k = 0; k < n; k++) {
				scanf("%d", &pixel[i][j][k]);
			}
		}
	}
	for (int i = 0; i < slice; i++) {
		for (int j = 0; j < m; j++) {
			for (int k = 0; k < n; k++) {
				if (pixel[i][j][k] == 1 && inq[i][j][k] == false) {
					ans += BFS(i, j, k);
				}
			}
		}
	}
	printf("%d", ans);
	return 0;
}

A1092

#include<iostream>
#include<string>
using namespace std;
int main() {
	int  hashtable[128] = { 0 };
	string s1, s2;
	int miss = 0;
	getline(cin, s1);
	getline(cin, s2);
	int len1 = s1.length();
	int len2 = s2.length();
	for (int i = 0; i < len1; i++) {
		hashtable[s1[i]]++;
	}
	for (int j = 0; j < len2; j++) {
		if (hashtable[s2[j]] > 0) {
			hashtable[s2[j]]--;
		}
		else {
			miss++;
		}
	}
	if (miss > 0) printf("No %d", miss);
	else printf("Yes %d", len1 - len2);
	return 0;
}

A1093

#include<string>
#include<iostream>
using namespace std;
const int maxn = 100010;
int main() {
	string str;
	cin >> str;
	int left_p[maxn] = { 0 };
	int len = str.length();
	for (int i = 0; i < len; i++) {
		if (i > 0) {
			left_p[i] = left_p[i - 1];
		}
		if (str[i] == 'P') {
			left_p[i]++;
		}
	}
	int res=0,count_T=0;
	for (int i = len-1; i >=0; i--) {
		if (str[i] == 'T') {
			count_T++;
		}
		if (str[i] == 'A') {
			res = (res + (left_p[i] * count_T) % 1000000007) % 1000000007;
		}
	}
	cout << res;
	return 0;
}

A1094

#include<cstdio>
#include<vector>
using namespace std;
const int maxn = 110;
vector<int> child[maxn];
int hashtable[maxn] = { 0 };
void DFS(int index, int level) {
	hashtable[level]++;
	if (child[index].size() == 0) return;
	for (int i = 0; i < child[index].size(); i++) {
		DFS(child[index][i], level + 1);
	}
}
int main(){
	int n,m,index,k,temp;
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= m; i++) {
		scanf("%d%d", &index,&k);
		for (int j = 1; j <= k; j++) {
			scanf("%d", &temp);
			child[index].push_back(temp);
		}
	}
	DFS(1, 1);
	int level, maxgeneration = 0;
	for (int i = 1; i < maxn; i++) {
		if (hashtable[i] > maxgeneration) {
			maxgeneration = hashtable[i];
			level = i;
		}
	}
	printf("%d %d", maxgeneration, level);
	return 0;
}

A1096

#include<cstdio>
#include<cmath>
int main() {
	long long  n;
	scanf("%lld", &n);
	long long  sqr = sqrt(n * 1.0);
	long long len=0, first;
	for (long long i = 2; i <= sqr; i++) {
		long long j = i, product = 1 ;
		while (1) {
			product *= j;
			if (n % product != 0) break;
			else {
				if (j - i + 1 > len) {
					len = j - i + 1;
					first = i;
				}
			}
			j++;
		}
	}
	if (len == 0) {
		printf("1\n");
		printf("%lld", n);
	}
	else {
		printf("%lld\n", len);
		for (long long i = first; i < first + len; i++) {
			if (i == first) printf("%lld", i);
			else printf("*%lld", i);
		}
	}
	return 0;
}

A1097

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=100010;
struct Node{
	int address,key,next;
	int order;
}node[maxn];
bool cmp(Node a,Node b){
	return a.order<b.order;
}
bool judge[maxn]={false};
int main(){
	int begin,n,address;;
	scanf("%d%d",&begin,&n);
	for(int i=0;i<maxn;i++){
		node[i].order=2*maxn;
	}
	for(int i=0;i<n;i++){
		scanf("%d",&address);
		scanf("%d%d",&node[address].key,&node[address].next);
		node[address].address=address;
	}
	int p=begin,countvalid=0,countremoved=0;
	while(p!=-1){
		if(judge[abs(node[p].key)]==false){
			judge[abs(node[p].key)]=true;
			node[p].order=countvalid++;
		}
		else{
			node[p].order=maxn+countremoved++;
		}
		p=node[p].next;
	}
	sort(node,node+maxn,cmp);
	int count=countvalid+countremoved;
	for(int i=0;i<count;i++){
		if(i!=countvalid-1&&i!=count-1){
			printf("%05d %d %05d\n",node[i].address,node[i].key,node[i+1].address);
		}
		else{
			printf("%05d %d -1\n",node[i].address,node[i].key);
		}
	}
	return 0;
}

A1098

#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
const int maxn = 110;
void downadjust(vector<int> &b,int low, int high) {
	int i = low, j = 2 * i;
	while (j <= high) {
		if (j + 1 <= high && b[j + 1] > b[j]) {
			j = j + 1;
		}
		if (b[i] < b[j]) {
			swap(b[i], b[j]);
			i = j;
			j = 2 * i;
		}
		else {
			break;
		}
	}
}
int main() {
	int n,p=2;
	scanf("%d", &n);
	vector<int>a(n + 1);
	vector<int>b(n + 1);
	for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
	for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
	while (p <= n && b[p - 1] <= b[p]) p++;
	int k = p;
	while (a[p] == b[p]&&p<=n) p++;
	if (p == n + 1) {
		printf("Insertion Sort\n");
		sort(b.begin() + 1, b.begin() + k + 1);
	}
	else {
        printf("Heap Sort\n");
		p = n;
		while (p > 2 && b[p] >= b[1]) p--;
		swap(b[1], b[p]);
		downadjust(b, 1, p - 1);
	}
    printf("%d", b[1]);
	for (int i = 2; i <= n; i++) printf(" %d", b[i]);
	return 0;
}

A1099

#include<cstdio>
#include<queue>
#include<algorithm>
using namespace std;
const int maxn = 110;
int n,inorder[maxn],index=0,num=0;
struct node {
	int data;
	int left, right;
}Node[maxn];
void in_insert(int root) {
	if (root == -1) return;
	in_insert(Node[root].left);
	Node[root].data = inorder[index++];
	in_insert(Node[root].right);
}
void BFS(int root) {
	queue<int>q;
	q.push(root);
	while (!q.empty()) {
		int now = q.front();
		q.pop();
		printf("%d", Node[now].data);
		num++;
		if (num < n) printf(" ");
		if (Node[now].left != -1) q.push(Node[now].left);
		if (Node[now].right != -1) q.push(Node[now].right);
	}
}
int main() {
	scanf_s("%d", &n);
	int root = 0;
	for (int i = 0; i < n; i++) {
		scanf_s("%d%d", &Node[i].left, &Node[i].right);
	}
	for (int i = 0; i < n; i++) {
		scanf_s("%d", &inorder[i]);
	}
	sort(inorder, inorder + n);
	in_insert(0);
	BFS(0);
	return 0;
}

A1100

#include<cstdio>
#include<iostream>
#include<map>
#include<string>
using namespace std;
string s1[13] = { "tret","jan", "feb", "mar", "apr", "may", "jun", "jly", "aug", "sep", "oct", "nov", "dec" };
string s2[13] = { "tret","tam", "hel", "maa", "huh", "tou", "kes","hei", "elo", "syy", "lok", "mer", "jou" };
map<string, int>strtonum;
int main() {
	int n;
	string str;
	scanf("%d%*c", &n);
	while (n--) {
		getline(cin, str);
		if (str[0] >= '0' && str[0] <= '9') {
			int number = stoi(str);
			if (number < 13) cout << s1[number]<<endl;
			else {
				int unit = number % 13;
				number /= 13;
				int tens = number % 13;
				if (unit == 0) cout << s2[tens] << endl;
				else cout << s2[tens] << " " << s1[unit] << endl;
			}	
		}
		else {
			for (int i = 0; i < 13; i++) {
				strtonum[s1[i]] = i;
			}
			for (int i = 1; i < 13;i++ ) {
				strtonum[s2[i]] = 13 * i;
			}
			for (int i = 1; i < 13; i++) {
				for (int j = 0; j < 13; j++) {
					strtonum[s2[i] +" "+s1[j]] = i * 13 + j;
				}
			}
			cout << strtonum[str] << endl;
		}
	}
	return 0;
}

A1101

#include<iostream>
using namespace std;
const int maxn = 100010;
const int INF = 0x7fffffff;
int main() {
	int a[maxn], leftmax[maxn]  , rightmin[maxn] ;
	int n;
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> a[i];
	}
    leftmax[0]=0;
	for (int i = 1; i < n; i++) {
			leftmax[i] = leftmax[i - 1];
			if (a[i - 1] > leftmax[i]) leftmax[i] = a[i-1];
	}
	rightmin[n - 1] = INF;
	for (int i = n - 2; i >= 0; i--) {
		rightmin[i] = rightmin[i + 1];
		if (a[i + 1] < rightmin[i]) rightmin[i] = a[i + 1];
	}
	int count=0, num[maxn];
	for (int i = 0; i < n; i++) {
		if (a[i] > leftmax[i] && a[i] <rightmin[i]) {
			num[count++] = a[i];
		}
	}
	cout << count<<endl;
	if(count!=0){
         cout << num[0];
	    for (int i = 1; i < count; i++) cout << " " << num[i];
    }
    cout<<endl;
	return 0;
}

A1102

#include<cstdio>
#include<queue>
#include<cctype>
#include<algorithm>
using namespace std;
struct node {
	int lchild, rchild;
}Node[11];
int n;
void layerorder(int root) {
	int num = 0;
	queue<int> q;
	q.push(root);
	while (!q.empty()) {
		int now = q.front();
		q.pop();
		printf("%d", now);
		num++;
		if (num < n) printf(" ");
		if (Node[now].lchild != -1) q.push(Node[now].lchild);
		if (Node[now].rchild != -1) q.push(Node[now].rchild);
	}
}
int num1 = 0; 
void inorder(int root) {
	if (root == -1) return;
    inorder(Node[root].lchild);
	printf("%d", root);
	num1++;
	if (num1 < n) printf(" ");
	inorder(Node[root].rchild);
}
void postorder(int root) {
	if (root == -1) return;
	postorder(Node[root].lchild);
	postorder(Node[root].rchild);
	swap(Node[root].lchild, Node[root].rchild);
}
int main() {
	bool notroot[11] = { false };
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		char a, b;
		scanf("%*c%c %c", &a, &b);
		if (isdigit(a)) {
			Node[i].lchild = a - '0';
			notroot[Node[i].lchild] = true;
		}
		else {
			Node[i].lchild = -1;
		}
		if (isdigit(b)) {
			Node[i].rchild = b - '0';
			notroot[Node[i].rchild] = true;
		}
		else {
			Node[i].rchild = -1;
		}
	}
	int root;
	for (int i = 0; i < n; i++) {
		if (notroot[i] == false) {
			root = i;
			break;
		}
	}
	postorder(root);
	layerorder(root);
	printf("\n");
	inorder(root);
	return 0;
}

A1103

#include<vector>
#include<cstdio>
#include<cmath>
using namespace std;
int n, k, p,maxfacsum=-1;
vector<int> temp, ans, fac;
void init() {
	int i = 0, temp=0;
	while (temp <= n) {
		fac.push_back(temp);
		temp = (int)pow(1.0 * (++i),1.0* p);
	}
}
void DFS(int index, int nowk, int sum, int facsum) {
	if (sum == n && nowk == k) {
		if (facsum > maxfacsum) {
			ans = temp;//更新最优序列
			maxfacsum = facsum;
		}
		return;
	}
	if (nowk > k || sum > n) return;
	if (index - 1 >= 0) {
		temp.push_back(index);
		DFS(index, nowk + 1, sum + fac[index], facsum + index);
		temp.pop_back();
		DFS(index - 1, nowk, sum, facsum);
	}
}
int main() {
	scanf("%d%d%d", &n, &k, &p);
	init();
	DFS(fac.size() - 1, 0, 0, 0);
	if (maxfacsum == -1) printf("Impossible");
	else {
		printf("%d = %d^%d", n, ans[0], p);
		for (int i = 1; i < ans.size(); i++) {
			printf(" + %d^%d", ans[i], p);
		}
	}
	return 0;
}

A1104

#include<cstdio>
const int maxn = 100010;
int main() {
	int n;
	double a[maxn],sum=0;
	scanf("%d", &n);
	for (int i = 1; i <= n; i++) {
		scanf("%lf", &a[i]);
        sum += a[i] * (n - i + 1) * i;
	}
	printf("%.2f", sum);
	return 0;
}

A1105

#include<cstdio>
#include<algorithm>
#include<vector>
#include<cmath>
using namespace std;
const int maxn=100;
bool cmp(int a,int b){
	return a>b;
}
int main(){
	int N,n,m,st=0;
	scanf("%d",&N);
	vector<int> a(N);
	for(int i=0;i<N;i++) scanf("%d",&a[i]);
	n=sqrt(1.0*N);
	while(n>=1){
		if(N%n==0) break;
		n--;
	}
	m=N/n;
	int level=m/2+m%2;
	sort(a.begin(),a.end(),cmp);
	int putm=m,putn=n;
	vector<vector<int> > ans(m, vector<int>(n));
	for(int i=0;i<level;i++){
		for(int j=i;j<n&&st<=N-1;j++) ans[i][j]=a[st++];
		for(int k=i+1;k<=m-2&&st<=N-1;k++) ans[k][n-1]=a[st++];
		for(int x=n-1;x>=i&&st<=N-1;x--) ans[m-1][x]=a[st++];
		for(int t=m-2;t>=i+1&&st<=N-1;t--) ans[t][i]=a[st++];
		n--;
		m--;
	}
	for(int i=0;i<putm;i++){
		for(int j=0;j<putn;j++){
			printf("%d",ans[i][j]);
			if(j<putn-1) printf(" ");
		}
		printf("\n");
	}
	return 0;
}

A1106

#include<cstdio>
#include<vector>
#include<cmath>
using namespace std;
const int maxn = 100010;
const int  INF = 0x7fffffff;
vector<int> child[maxn];
double minprice = INF;
int n,num=0;
double p, r;
void DFS(int index, int depth) {
	if (child[index].size() == 0) {
		if (p * pow((1 + r/100), depth) < minprice) {
			minprice = p * pow((1 + r/100), depth);
			num = 1;
		}
		else if (p * pow((1 + r/100), depth) == minprice) {
			num++;
		}
		return;
	}
	for (int i = 0; i < child[index].size(); i++) {
		DFS(child[index][i], depth + 1);
	}
}
int main() {
	scanf("%d%lf%lf", &n, &p, &r);
	int  k,temp;
	for (int i = 0; i < n; i++) {
		scanf("%d", &k);
		if (k == 0) continue;
		else {
			for (int j = 0; j < k; j++) {
				scanf("%d", &temp);
				child[i].push_back(temp);
			}
		}
	}
	DFS(0, 0);
	printf("%.4f %d", minprice, num);
	return 0;
}

A1107

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=1010;
int n;
int father[maxn];
int isroot[maxn]={0};
int course[maxn]={0};
bool cmp(int a,int b){
	return a>b;
}
int findfather(int v){
	if(father[v]==v) return v;
	else{
		int F=findfather(father[v]);
		father[v]=F;
		return F;
	}
}
void Union(int a,int b){
	int fatherA=findfather(a);
	int fatherB=findfather(b);
	if(fatherA!=fatherB){
		father[fatherA]=fatherB;
	}
}
void init(int x){
	for(int i=1;i<=n;i++){
		father[i]=i;
	}
}
int main(){
	int k,h;
	scanf("%d",&n);
	init(n);
	for(int i=1;i<=n;i++){
		scanf("%d:",&k);
		for(int j=0;j<k;j++){
			scanf("%d",&h);
			if(course[h]==0){
				course[h]=i;
			}
			Union(i,findfather(course[h]));
		}
	}
	for(int i=1;i<=n;i++){
		isroot[findfather(i)]++;
	}
	int ans=0;
	for(int i=1;i<=n;i++){
		if(isroot[i]!=0){
			ans++;
		}
	}
	printf("%d\n",ans);
	sort(isroot+1,isroot+n+1,cmp);
	for(int i=1;i<=ans;i++){
		printf("%d",isroot[i]);
		if(i<ans) printf(" ");
	}
	return 0;
}

A1108

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
int main() {
	char a[100],b[100];
	int n,cnt=0;
	scanf("%d",&n);
	double temp, sum = 0.0;
	for (int i = 0; i < n; i++) {
		scanf("%s", a);
		sscanf(a, "%lf", &temp);
		sprintf(b, "%.2f", temp);
		bool flag = false;
		for (int j = 0; j < strlen(a); j++) {
			if (a[j] != b[j]) flag = true;
		}
		if (flag || temp < -1000 || temp>1000) {
			printf("ERROR: %s is not a legal number\n", a);
		}
		else {
			sum += temp;
			cnt++;
		}
	}
	if (cnt == 0) printf("The average of 0 numbers is Undefined");
	else if (cnt == 1) printf("The average of 1 number is %.2f", sum);
	else printf("The average of %d numbers is %.2f", cnt, sum / cnt);
	return 0;
}

A1109

#include<iostream>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
const int maxn = 10010;
struct node {
	int height;
	char name[10];
}person[maxn];
bool cmp(node a, node b) {
	if (a.height != b.height) return a.height > b.height;
	else return strcmp(a.name, b.name) < 0;
}
int main() {
	int n, k, cnt = 0;
	cin >> n >> k;
	for (int i = 0; i < n; i++) {
		cin >> person[i].name;
		cin >> person[i].height;
	}
	int rownum = n / k;
	sort(person, person + n, cmp);
	for (int i = 0; i < k; i++) {
		vector<node> ans(n+1);
		int num;
		if (i == 0)  num = n - (rownum * (k - 1));
		else  num = rownum;
		ans[num / 2 + 1] = person[cnt++];
		for (int j = 1; j <= num / 2; j++) {
			if ((num / 2 + 1 - j) >= 1) ans[num / 2 + 1 - j] = person[cnt++];
			if ((num / 2 + 1 + j) <= num) ans[num / 2 + 1 + j] = person[cnt++];
		}
		for (int j = 1; j <= num; j++) {
			cout << ans[j].name;
			if (j < num) cout << " ";
		}
		cout << endl;
		ans.clear();
	}
	return 0;
}

A1110

#include<iostream>
#include<string>
using namespace std;
struct node {
	int lchild;
	int rchild;
}a[21];
int ans, maxn = -1;
void dfs(int root, int index) {
	if (index > maxn) {
		maxn = index;
		ans = root;
	}
	if (a[root].lchild != -1) dfs(a[root].lchild, index * 2);
	if (a[root].rchild != -1) dfs(a[root].rchild, index * 2 + 1);
}
int main() {
	int root = 0,n, have[30] = { 0 };
	string c;
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> c;
		if (c == "-") a[i].lchild = -1;
		else {
			a[i].lchild = stoi(c);
			have[a[i].lchild] = 1;
		}
		cin >> c;
		if (c == "-") a[i].rchild = -1;
		else {
			a[i].rchild = stoi(c);
			have[a[i].rchild] = 1;
		}
	}
	while (have[root] != 0) root++;
	dfs(root, 1);
	if (maxn == n) cout << "YES " << ans;
	else cout << "NO " << root;
	return 0;
}

A1112

#include<iostream>
#include<cstdio>
#include<vector>
#include<string>
#include<map>
using namespace std;
int main(){
	bool surenobroken[256]={false},hasprint[256]={false};
	map<char,bool> broken;
	vector<char> needprint;
	string s;
	int k;
	scanf("%d",&k);
	cin>>s;
	int cnt=1;
	char pre='@';
	s=s+'@';
	for(int i=0;i<s.size();i++){
		if(s[i]==pre){
			cnt++;
		}else{
			if(cnt%k!=0) surenobroken[pre]=true;
			cnt=1;
		}
		if(i<s.size()-1) broken[s[i]]=(cnt%k==0);
		pre=s[i];
	}
	for(int i=0;i<s.size()-1;i++){
		if(surenobroken[s[i]]==true) broken[s[i]]=false;
		if(broken[s[i]]==true&&hasprint[s[i]]==false){
			needprint.push_back(s[i]);
			hasprint[s[i]]=true;
		}
	}
	for(int i=0;i<needprint.size();i++) cout<<needprint[i];
	cout<<endl;
    for(int i=0;i<s.length()-1;i++){
    	cout<<s[i];
    	if(broken[s[i]]==true) i=i+k-1;
	}
	return 0;
}

A1116

#include<cstdio>
#include<cmath> 
#include<algorithm>
using namespace std;
const int maxn=10010;
bool isprime(int n){
	if(n<=1) return false;
	int sqr=sqrt(1.0*n);
	for(int i=2;i<=sqr;i++){
		if(n%i==0) return false;
	}
	return true;
}
int main(){
	int id,n,k,rank[maxn],query;
	bool vis[maxn]={false};
	scanf("%d",&n);
	fill(rank,rank+maxn,0);
	for(int i=1;i<=n;i++){
		scanf("%d",&id);
		rank[id]=i;
	}
	scanf("%d",&k);
	while(k--){
		scanf("%d",&query);
		if(rank[query]==0) printf("%04d: Are you kidding?\n",query);
		else{
			if(vis[query]==true) printf("%04d: Checked\n",query);
		    else{
		    	vis[query]=true;
		    	if(rank[query]==1) printf("%04d: Mystery Award\n",query);
		    	else if(isprime(rank[query])) printf("%04d: Minion\n",query);
		    	else printf("%04d: Chocolate\n",query);
			}
		}
	}
	return 0;
}

A1120

#include<iostream>
#include<set>
#include<string>
using namespace std;
const int maxn=10010;
int main(){
	int n,sum[maxn]={0};
	string str;
	set<int> ans;
	cin>>n;
	bool flag[maxn]={false};
	for(int i=0;i<n;i++){
		cin>>str;
		int len=str.size();
		for(int j=0;j<len;j++){
			sum[i]+=(str[j]-'0');
		}
	}
	for(int i=0;i<n;i++) ans.insert(sum[i]);
	printf("%d\n",ans.size());
	for(auto it=ans.begin();it!=ans.end();it++) {
		if(it!=ans.begin()) printf(" %d",*it);
		else printf("%d",*it);
	}
	return 0;
}

A1141

#include<cstdio>
#include<iostream> 
#include<map>
#include<cctype>
#include<string>
#include<algorithm>
using namespace std;
const int maxn=100010;
struct node{
	string name;
	double totalscore;
	int num;
}school[maxn];
bool cmp(node a,node b){
	if((int)a.totalscore!=(int)b.totalscore) return (int)a.totalscore>(int)b.totalscore;
	else if(a.num!=b.num) return a.num<b.num;
	else return a.name<b.name;
}
map<string,int> s;
int main(){
	int n,num=0;
	double score;
	string id,schoolname;
	scanf("%d",&n);
	for(int i=0;i<maxn;i++){
		school[i].totalscore=0;
		school[i].num=0;
	}
	for(int i=0;i<n;i++){
		cin>>id>>score>>schoolname;
		for(int j=0;j<schoolname.size();j++){
			if(isupper(schoolname[j])) schoolname[j]+=32;
		}
		if(s.count(schoolname)==0){
			s[schoolname]=num;
			school[s[schoolname]].name=schoolname;
			num++;
		}
		if(id[0]=='B') score=score/1.5;
		if(id[0]=='T') score=score*1.5;
		school[s[schoolname]].totalscore+=score;
		school[s[schoolname]].num++;
	}
	cout<<num<<endl;
	sort(school,school+num,cmp);
	int r=1;
	printf("%d %s %d %d\n",r,school[0].name.c_str(),(int)school[0].totalscore,school[0].num);
	for(int i=1;i<num;i++){
		if((int)school[i].totalscore!=(int)school[i-1].totalscore) r=i+1;
		printf("%d %s %d %d\n",r,school[i].name.c_str(),(int)school[i].totalscore,school[i].num);
	}
	return 0;
}

A1144

#include<cstdio>
#include<map>
using namespace std;
int main(){
    int n,temp,num=0;
    map<int,int> s;
    scanf("%d",&n);
    for(int i=0;i<n;i++) {
        scanf("%d",&temp);
        s[temp]++;
    }
    while(++num){
        if(s.count(num)==0){
            printf("%d",num);
            break;
        }
    }
    return 0;
}

A1151

#include<cstdio>
#include<map>
#include<vector>
using namespace std;
const int maxn=10010;
map<int,int> pos;
vector<int> ins,pre;
void lca(int inl,int inr,int preroot,int a,int b){
	if(inl>inr) return;
	int inroot=pos[pre[preroot]],ain=pos[a],bin=pos[b];
	if(ain<inroot&&bin<inroot) lca(inl,inroot-1,preroot+1,a,b);
	else if((ain<inroot&&bin>inroot)||(ain>inroot&&bin<inroot)){
		printf("LCA of %d and %d is %d.\n",a,b,ins[inroot]);
	}
	else if(ain>inroot&&bin>inroot) lca(inroot+1,inr,preroot+1+(inroot-inl),a,b);
	else if(ain==inroot) printf("%d is an ancestor of %d.\n",a,b);
	else if(bin==inroot) printf("%d is an ancestor of %d.\n",b,a);
}
int main(){
	int m,n,a,b;
	scanf("%d%d",&m,&n);
	ins.resize(n + 1), pre.resize(n + 1);
	for(int i=1;i<=n;i++){
		scanf("%d",&ins[i]);
		pos[ins[i]]=i;
	}
	for(int i=1;i<=n;i++) scanf("%d",&pre[i]);
	for(int i=0;i<m;i++){
		scanf("%d%d",&a,&b);
		if(pos.count(a)==0&&pos.count(b)!=0) printf("ERROR: %d is not found.\n",a);
		if(pos.count(b)==0&&pos.count(a)!=0) printf("ERROR: %d is not found.\n",b);
		if(pos.count(a)==0&&pos.count(b)==0) printf("ERROR: %d and %d are not found.\n",a,b);
		if(pos.count(a)!=0&&pos.count(b)!=0) lca(1,n,1,a,b);
	}
	return 0;
}