恩，写这个纯粹是为了算法老师的作业，无它...就是以前写了好多次的并查集，不过这个更纯粹...

描述 Description

若某个家族人员过于庞大，要判断两个是否是亲戚，确实还很不容易，现在给出某个亲戚关系图，求任意给出的两个人是否具有亲戚关系。
规定：x和y是亲戚，y和z是亲戚，那么x和z也是亲戚。如果x,y是亲戚，那么x的亲戚都是y的亲戚，y的亲戚也都是x的亲戚。

输入格式 Input Format

第一行：三个整数n,m,p，（n<=5000,m<=5000,p<=5000），分别表示有n个人，m个亲戚关系，询问p对亲戚关系。
以下m行：每行两个数Mi，Mj，1<=Mi，Mj<=N，表示Ai和Bi具有亲戚关系。
接下来p行：每行两个数Pi，Pj，询问Pi和Pj是否具有亲戚关系。

输出格式 Output Format

P行，每行一个’Yes’或’No’。表示第i个询问的答案为“具有”或“不具有”亲戚关系。

Tip:就是简单并查集。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

#include <iostream>
#include <stdlib.h>
#define MAX 5001
 
using namespace std;
 
// father[x]表示x的父节点
int father[MAX];
 
// 初始化集合
void Make_Set(int x)
{
	father[x] = x;
}
 
// 查找x元素所在的集合,回溯时压缩路径
int Find_Set(int x)
{
	if (x != father[x])
	{
		father[x] = Find_Set(father[x]);
	}
	return father[x];
}
 
// 合并x,y所在的集合
void Union(int x, int y)
{
	x = Find_Set(x);
	y = Find_Set(y);
	if (x == y)
	{
		return;
	}
	else
	{
		father[y] = x;
	}
}
 
int main()
{
	int n, m, p;
	int x, y;
	cin >> n >> m >> p;
 
	// 初始化 
	for (int i = 1; i <= n; i++)
	{
		Make_Set(i);
	}
 
	//读入亲戚关系 
	for (int i = 1; i <= m; i++)
	{
		cin >> x >> y;
		Union(x, y);
	}
 
	//询问亲戚关系 
	while (p--)
	{
		cin >> x >> y;
		if (Find_Set(x) == Find_Set(y))
		{
			cout << "Yes" << endl;
		}
		else
		{
			cout << "No" << endl;
		}
	}
 
	system("pause");
	return 0;
}

背景 Background

Zhang Gangrui 年纪大了，记性不好，保险箱的密码记不住了，他只记得密码是一个数的阶乘各个位的数相加的和，最后还有个T或F，代表这个数是否为素数，正好，你到他家去了，他请你帮他这个忙，并答应事成之后给你100000000 MOD 10 RMB。

描述 Description

输入一个整数n（1000>=n>=0）
输出n的阶乘各个位的数相加的和y，最后再输出T或F，
代表y是否为素数。

输入格式 Input Format

输入一个整数n（1000>=n>=0

输出格式 Output Format

输出n的阶乘各个位的数相加的和y，最后再输出对y是否为素数的判断，
是为T否为F。

Tip:首先是高精度阶乘，之后的素数判断只看n就可以了，当n=2或者n=5时，结果为素数，其他的n结果一定是素数，因为3!以后各位数加起来一定是3的倍数。

#include <stdio.h>

int main(){
int i,j,n,jinwei,weishu=1,temp,x[10000],sum=0;
scanf("%d",&n);
x[0]=1;
for(i=2;i<=n;i++){
jinwei=0;
for(j=1;j<=weishu;j++){
temp=x[j-1]*i+jinwei;
x[j-1]=temp%10;
jinwei=temp/10;
}
while(jinwei){
weishu++;
x[weishu-1]=jinwei%10;
jinwei=jinwei/10;
}
}
for(j=weishu-1;j>=0;j--) sum+=x[j];
if ((n==2)||(n==5)) printf("%dT",sum);
else printf("%dF",sum);
return 0;
}

描述 Description

有形如：ax^3+bx^2+cx+d=0  这样的一个一元三次方程。给出该方程中各项的系数(a，b，c，d  均为实数)，并约定该方程存在三个不同实根(根的范围在-100至100之间)，且根与根之差的绝对值>=1。要求由小到大依次在同一行输出这三 个实根(根与根之间留有空格)，并精确到小数点后2位。
提示：记方程f(x)=0，若存在2个数x1和x2，且x1<x2，f(x1)*(x2)<0，则在(x1，x2)之间一定有一个根。

输入格式 Input Format

输入该方程中各项的系数(a，b，c，d  均为实数)

输出格式 Output Format

由小到大依次在同一行输出这三个实根(根与根之间留有空格)，并精确到小数点后2位。

Tip:直接暴力枚举就行了，扩大100倍可以忽略实数误差。注意整型/实型才是实型，所以那个100必须写成100.0。

#include <stdio.h>

int main(){
float a,b,c,d,x;
int i;
scanf("%f%f%f%f",&a,&b,&c,&d);
for (i=-10000;i<=10000;i++){
x=i/100.0;
if ((a*x*x*x+b*x*x+c*x+d>-0.0001)&&(a*x*x*x+b*x*x+c*x+d<0.0001))
printf("%.2f ",x);
}
system("pause");
return 0;
}

描述 Description

有N个一种松鼠喜欢吃的果子由下向上串排成一列，并标号1,2,...N。一只松鼠从最下果子开始向上跳，并且第i次跳可以一次跳过i*i*i除以5的余 数+1个果子(=i*i*i%5+1)，并把脚下的果子吃了，如果上面有果子，在重力作用下，都将向下掉下一格。如第1次跳从第一个果子上跳过 1*1*1%5+1=2个果子，可跳到第3个果子上，并把第3个果子吃了；第2次从第4个果子上(落在原来第三个果子位置)跳过2*2*2%5+1=4个 到第8个果子上，并把第8个吃了；如此...
当然，总有一次松鼠会跳出这串果子的最前面，设为每K次，它吃不到任何果子了。这时它回到最下面的果子上，重做它的第K次跳，以求吃到果子。如此，问它吃的第m只果子(即第M跳吃到的果子)的标号是什么？

输入格式 Input Format

一共两行，分别为N和m。（1<=m<=n<=200，并且满足能够跳到第m次）

输出格式 Output Format

一个数，即它吃的第m只果子的标号。

Tip:又是模拟。。。我恨模拟。。。好在这题比较简单。。。

#include <stdio.h>

int main(){
int i,j,n,m,guo[201],step,height=1,num;
scanf("%d%d",&n,&m);
for (i=1;i<=n;i++) guo[i]=i;
for (i=1;i<=m;i++){
step=i*i*i%5+1;
if (height+step<=n-i+1) height+=step;
else height=step+1;
num=guo[height];
for (j=height;j<=n-i;j++) guo[j]=guo[j+1];
}
printf("%d",num);
system("pause");
return 0;
}

描述 Description

对于一群要互送礼物的朋友，你要确定每个人送出的礼物比收到的多多少。
在这一个问题中，每个人都准备了一些钱来送礼物，而这些钱将会被平均分给那些将收到他的礼物的人。
然而，在任何一群朋友中，有些人将送出较多的礼物(可能是因为有较多的朋友)，有些人有准备了较多的钱。
给出一群朋友， 没有人的名字会长于 14 字符，给出每个人将花在送礼上的钱，和将收到他的礼物的人的列表，
请确定每个人收到的比送出的钱多的数目。

输入格式 Input Format

第 1 行: 人数NP,2<= NP<=10

第 2到 NP+1 行:
这NP个在组里人的名字　一个名字一行

第NP＋2到最后：
这里的NP段内容是这样组织的：
第一行是将会送出礼物人的名字。
第二行包含二个数字:　第一个是原有的钱的数目（在0到2000的范围里），第二个NGi是将收到这个送礼者礼物的人的个数 如果 NGi 是非零的, 在下面 NGi 行列出礼物的接受者的名字，一个名字一行。

输出格式 Output Format

输出 NP 行
每行是一个的名字加上空格再加上收到的比送出的钱多的数目。
对于每一个人，他名字的打印顺序应和他在输入的2到NP＋1行中输入的顺序相同。所有的送礼的钱都是整数。
每个人把相同数目的钱给每位要送礼的朋友，而且尽可能多给，不能给出的钱被送礼者自己保留。

Tip:该死的模拟。。。我最讨厌做模拟题了。。。一点难度也没有做了3个小时才出来，第一次居然写了70多行，我靠。。。还好一次AC,要WA了我就不做了。。。这题还是pascal做好，不习惯用C的结构体，用pascal直接数组都能搞定，可恶的是C没有字符串变量。。。

#include <stdio.h>
#include <string.h>

int i,j,k,n,song,shou,qian;
char ren[15];
struct data{
char name[15];
int money,in,out,renshu;
}stu[11];

int cmp(struct data p[],char q[]){
int i,j;
for (i=1;i<=n;i++){
j=strcmp(p[i].name,q);
if (j==0) return i;
}
}

int main(){
scanf("%d",&n);
for (i=1;i<=n;i++){
scanf("%s",&stu[i].name);
stu[i].in=0;
stu[i].out=0;
stu[i].money=0;
}
for (i=1;i<=n;i++){
scanf("%s",&ren);
song=cmp(stu,ren);
scanf("%d%d",&stu[song].money,&stu[song].renshu);
if (stu[song].renshu==0) continue;
qian=stu[song].money/stu[song].renshu;
for (j=1;j<=stu[song].renshu;j++){
scanf("%s",ren);
shou=cmp(stu,ren);
stu[song].out+=qian;
stu[shou].in+=qian;
}
}
for (i=1;i<=n;i++)
printf("%s %d\n",stu[i].name,stu[i].in-stu[i].out);
system("pause");
return 0;
}

描述 Description

Matrix67和Shadow正在做一个小游戏。
桌子上放着两堆糖果，Matrix67和Shadow轮流对这些糖果进行操作。在每一次操作中，操作者需要吃掉其中一堆糖果，并且把另一堆糖果分成两 堆（可以不相等）留给对方操作。游戏如此进行下去，糖果数会越来越少，最后必将出现这样一种情况：某人吃掉一堆糖果后发现另一堆里只剩一块糖果不能再分 了。游戏规定此时该操作者吃掉最后这一块糖果从而取胜。
这个游戏是不公平的。对于任意一种初始状态，总有一方有必胜策略。所谓有必胜策略是指，无论对方如何操作，自己总有办法取胜。
Matrix67和Shadow将进行10次游戏，每一次游戏中总是Matrix67先进行操作。Matrix67想知道每一次游戏中谁有必胜策略。

输入格式 Input Format

输入数据一共10行，每行有两个用空格隔开的正整数，表示一次游戏开始时桌子上两堆糖果分别有多少个。
对于50%的数据，这些正整数均不超过100；
对于70%的数据，这些正整数均不超过10 000；
对于100%的数据，这些正整数均不超过10 000位。

输出格式 Output Format

输出十行字符串。这些字符串只能是“Matrix67”或“Shadow”，它们表示对应的十行输入数据中有必胜策略的一方。
请注意大小写。

Tip:当面临着糖果数为2或3的一堆时，你就输定了；枚举后发现发现，当面临糖果数为7或8的一堆时，你也输定了。另外像这种数位上万的，一般只要考虑尾数就好了。。。

#include <stdio.h>
#include <string.h>

int main(){
int i;
char x[10001],y[10001],a,b;
for (i=0;i<10;i++){
scanf("%s%s",x,y);
a=x[strlen(x)-1];
b=y[strlen(y)-1];
if (((a=='2')||(a=='3')||(a=='7')||(a=='8'))&&((b=='2')||(b=='3')||(b=='7')||(b=='8')))
printf("Shadow");
else
printf("Matrix67");
}
system("pause");
return 0;
}

描述 Description

为了庆祝黑皮的1006岁生日，也就是2006年01月01日。校长为他在学校里举行一个名为{天造奇才}的大型庆祝活动。邀请全校的师生及其家属们都 参加。考虑到当时人数相当庞大，黑皮的好友小佳佳特地为他从美国进口了个超级无敌大蛋糕1号。供到场的所有人享用。
黑皮也考虑到人数太多，蛋糕又只有一个。所以决定自己用在最少的刀数划出最多的蛋糕份数。比如说：开始是1个蛋糕，份数为1；黑皮一刀子划下去，刀数为1，份数就为2了；再一刀，刀数为2，份数为4；再一刀………………若干刀下去，份数就为n了。他想知道你们是否也能划出来。

输入格式 Input Format

输入一个数，即为黑皮当时划的刀数n。0<=n<=34567890;

输出格式 Output Format

一个数，即为到场人数。已知人数与黑皮划下来的份数相同。

Tip:可以知道每一刀与其他切过的线相交时分成的块数最多，所以增加的部分每次递增1，有f(n) = (n+1)*n/2 +1

另外一定注意精度。。。因为精度不够又WA了一次。。。

#include <stdio.h>

int main(){
double n;
scanf("%lf",&n);
printf("%.0lf",(n+1)*n/2+1);
system("pause");
return 0;
}

描述 Description

某小学最近得到了一笔赞助，打算拿出其中一部分为学习成绩优秀的前5名学生发奖学金。期末，每个学生都有3门课的成绩：语文、数学、英语。先按总分从高到 低排序，如果两个同学总分相同，再按语文成绩从高到低排序，如果两个同学总分和语文成绩都相同，那么规定学号小的同学排在前面，这样，每个学生的排序是唯 一确定的。

任务：先根据输入的3门课的成绩计算总分，然后按上述规则排序，最后按排名顺序输出前5名学生的学号和总分。注意，在前5名同学中，每个人的奖学金都 不相同，因此，你必须严格按上述规则排序。例如，在某个正确答案中，如果前两行的输出数据(每行输出两个数：学号、总分)是：
7 279
5 279

这两行数据的含义是：总分最高的两个同学的学号依次是7号、5号。这两名同学的总分都是279(总分等于输入的语文、数学、英语三科成绩之和)，但学号为7的学生语文成绩更高一些。如果你的前两名的输出数据是：
5 279
7 279

则按输出错误处理，不能得分。

输入格式 Input Format

输入包含n+1行：
第l行为一个正整数n，表示该校参加评选的学生人数。
第2到年n+l行，每行有3个用空格隔开的数字，每个数字都在0到100之间。第j行的3个数字依次表示学号为j-1的学生的语文、数学、英语的成绩。每个学生的学号按照输入顺序编号为1～n(恰好是输入数据的行号减1)。
所给的数据都是正确的，不必检验。

输出格式 Output Format

输出共有5行，每行是两个用空格隔开的正整数，依次表示前5名学生的学号和总分。

Tip:很简单，不说了，就是模拟的时候思路要清晰，我一开始就混乱了。。。

#include <stdio.h>

int main(){
int i,j,n,yu[301],x,y,sum[301]={0};
scanf("%d",&n);
for (i=1;i<=n;i++){
scanf("%d%d%d",&yu[i],&x,&y);
sum[i]=yu[i]+x+y;
}
x=0;
for (i=1;i<=5;i++){
for (j=1;j<=n;j++){
if (sum[j]>sum[x]||sum[j]==sum[x]&&yu[j]>yu[x])
x=j;
}
printf("%d %d\n",x,sum[x]);
sum[x]=0;
yu[x]=0;
}
system("pause");
return 0;
}

背景 Background

怪盗基德 VS OIBH
第4话
只偷了3块宝石的基德当然不会善罢甘休，他与OIBH又开始了新一轮的对决!这次
的目标是The Blue Wonder(大海的奇迹)。在《怪盗基德·奇异的空中步行》一
集中，怪盗基德以悬空的姿态在众人面前出现。这次你要帮助基德再次悬空登场！

描述 Description

The Blue Wonder被OIBH悬空挂在大厅的天花板上，距地面有m米的高度。大厅是
一个圆形的半球顶房间，直墙高度为n米。大厅半径为r米。基德可以在直墙上的
任意一点移动，但不能移动到半球顶上。基德需要用一根细丝连上Blue Wonder
来走上去（好厉害啊，钢丝杂技）。需要你帮他计算细丝的最短长度。

输入格式 Input Format

一行，三个实数m,n,r。

输出格式 Output Format

一行一个实数min，表示细丝的最短长度。你需要把这个数保留到3位小数。

Tip:简单题，注意精度，要用double才行。。。一开始用了float给WA了。。。

#include <stdio.h>
#include <math.h>

int main(){
double m,n,r,min;
scanf("%lf%lf%lf",&m,&n,&r);
if (n>=m) min=r;
else min=sqrt(pow(r,2)+pow(m-n,2));
printf("%.3lf",min);
system("pause");
return 0;
}

描述 Description

有n个球，从外表上看不出差别，但有一个球比其他球重，其他N-1个球质量相等。请问：在地球上（MS废话），用天平最少称几次可以称出来？

输入格式 Input Format

一个自然数N(0<N<=2^24)

输出格式 Output Format

输出用天平最小的称量数m(m<30000)

Tip:天平称量问题，证明我不会。。。

天平称重，有两个托盘比较轻重，加上托盘外面，也就是每次称重有3个结果，就是ln3/ln2比特信息。n个球要知道其中一个不同的球，如果知道那个不同重量的球是轻还是重，找出来的话那就是n个结果中的一种，就是有ln(n)/ln2比特信息，假设我们要称k次，根据信息理论：k*ln3/ln2>=ln(n)/ln2,解得k>=ln(n)/ln3

学会2个函数：

floor(x)返回的是小于或等于x的最大整数。

ceil(x)返回的是大于x的最小整数。

另外还有一点是：

ln(x) 在C中是log(x)

lg(x) 在C中是log10(x)

#include <stdio.h>
#include <math.h>

int main(){
long n,m;
scanf("%d",&n);
m=ceil(log(n)/log(3));
printf("%d",m);
system("pause");
return 0;
}

描述 Description

现代数学的著名证明之一是Georg Cantor证明了有理数是可枚举的。他是用下面这一张表来证明这一命题的：
1/1  1/2  1/3  1/4  1/5 …
2/1  2/2  2/3  2/4  …
3/1  3/2  3/3  …
4/1  4/2  …
5/1  …
…
我们以Z字形给上表的每一项编号。
第一项是1/1，然后是1/2，2/1，3/1，2/2，…

输入格式 Input Format

输入：整数N（1≤N≤10000000）

输出格式 Output Format

输出：表中的第N项

Tip:纯粹的数学问题，第K个斜行（"/"方向）上每个分数的分子分母之和为K+1，因此先算出第N项所在的斜行K，然后看斜行是奇数项还是偶数项，进而算出具体分数值。

#include <stdio.h>

int main(){
long i=0,n;
scanf("%ld",&n);
while (i<n){
n-=i;
i++;
}
if (i%2==0) printf("%d/%d",n,i+1-n);
else printf("%d/%d",i+1-n,n);
system("pause");
return 0;
}

描述 Description

明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤100），对于其中重复的数 字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“ 去重”与“排序”的工作。

输入格式 Input Format

输入有2行，第1行为1个正整数，表示所生成的随机数的个数：
N
第2行有N个用空格隔开的正整数，为所产生的随机数。

输出格式 Output Format

输出也是2行，第1行为1个正整数M，表示不相同的随机数的个数。第2行为M个用空格隔开的正整数，为从小到大排好序的不相同的随机数。

Tip:最简单的办法就是桶排序，这样进行一次筛选和排序就都出来了。

桶排序也叫基数排序。如果我们有N个整数，范围从1到M（或从0到M-1），我们留置一个数组A，大小为M，并初始化为0。于是该数组有M个单元（我们称之为桶）， 开始他们都是空的。当数a被读入时，A[a]增1。当所有的输入被读进时，扫描数组，打印出排好序的表。这就是所谓的桶排序。

#include <stdio.h>

int main(){
int i,j,n,sum=0,x[1001]={0};
scanf("%d",&n);
for (i=1;i<=n;i++){
scanf("%d",&j);
if (x[j]==0) sum++;
x[j]=1;
}
printf("%d\n",sum);
for (i=1;i<=1000;i++)
if (x[i]==1) printf("%d ",i);
system("pause");
return 0;
}

描述 Description

一天黑皮不务正业出去耍，看见街上的地板是由很多小的正方形组成，顿时心里突发奇想想要总结一下到底有多少正方形。。。。
于是乎，他狠下心数了数，终于翻山越岭知道了正方形的总边长为N，你的目的是找出在可以组成的每个至少边为1的正方形的个数。(因为黑皮太笨了，无法找到)。。

输入格式 Input Format

自然数(0<=n<=32767)

输出格式 Output Format

一个数，即正方形的总数

Tip:拿笔在纸上写几个数就知道这是自然数的平方和了，用 n*(n+1)*(2*n+1)/6 公式可以很方便地求出结果，但是第一次我WA了，最后三个数没过，想到可能是long不够，准备换成long long来算，可是中间试验的时候发现当n在10000左右的时候数据溢出了，换成double型也同样溢出。。。考虑到这可能是n*(n+1)*(2*n+1)/6 公式的问题。。。换成循环，没问题，提交，AC。。。

#include <stdio.h>

int main(){
int i,n;
double sum=0;
scanf("%ld",&n);
for (i=1;i<=n;i++) sum+=i*i;
printf("%.0lf",sum);
system("pause");
return 0;
}

描述 Description

对一个给定的自然数M，求出所有的连续的自然数段（连续个数大于1），这些连续的自然数段中的全部数之和为M。
例子：1998+1999+2000+2001+2002 = 10000，所以从1998到2002的一个自然数段为M=10000的一个解。

输入格式 Input Format

包含一个整数的单独一行给出M的值（10 <= M <= 2,000,000）

输出格式 Output Format

每行两个自然数，给出一个满足条件的连续自然数段中的第一个数和最后一个数，两数之间用一个空格隔开，所有输出行的第一个按从小到大的升序排列，对于给定的输入数据，保证至少有一个解。

Tip:枚举首项，然后用高斯定律就行了，适当缩小搜索范围可以提高速度。

#include <stdio.h>

int main(){
long n,i,j;
scanf("%ld",&n);
for (i=1;i<=n/2;i++)
for (j=i+1;j<=n;j++){
if ((i+j)*(j-i+1)/2>n) break;
if ((i+j)*(j-i+1)/2==n){
printf("%ld %ld\n",i,j);
break;
}
}
system("pause");
return 0;
}

背景 Background

Slyar设计了很多机器人。但是它们都认为自己是最强的，于是，一场比赛开始了~

描述 Description

机器人们都想知道谁是最聪明的，于是它们进行如下一种游戏。
这个游戏由2次机器人进行，2个机器人分别报出一个数n1,n2,谁报得大，就以这个数作为基数，并由它先开始，轮流进行如下操作：
选取一个不大于基数的素数或者1，从基数中扣掉它。谁把基数扣到0，谁就赢了。
为了公平，他们会进行10次比赛，请你分别输出这10次谁获胜了。

输入格式 Input Format

每组测试数据均有10行
每行2个数n1,n2 (n1,n2<=maxlongint n1<>n2)

输出格式 Output Format

对每组测试数据输出10行，每行一个整数1或2
表示哪个机器人能获胜

Tip:呃。。。这题是哥德巴赫猜想，一开始我也没想到。大于2 的素数可以表示成4K+1或4K-1，然后对4k,4k+1,4k+2,4k+3进行讨论就行了。。。最后结果是当n=4的时候，能减的数是1,2,3则必为败态，所以只要大数%4==0则必败。。。

#include <stdio.h>

int main(){
long i,n1,n2;
for (i=1;i<=10;i++){
scanf("%ld%ld",&n1,&n2);
if(n1>n2)
if (n1%4==0) printf("2");
else printf("1");
else
if (n2%4==0) printf("1");
else printf("2");
}
system("pause");
return 0;
}

描述 Description

柯南已经从灰原哀那里得到了一些关于OIBH组织的情报, 他想在阿笠把整理的资料打印出来, 仔细研究.
这份资料的正文包含许多行,某些行可能包含一些脚注标记,一个脚注可能包含一行或多行,并且必须和对应的脚注标记印刷在同一页
一页所允许印刷的最多行数是已知的，任何一页都不允许超过该行数(包括脚注)
但是阿笠博士的纸不多了, 柯南只好尽可能的少用纸, 他想知道这份资料最少要用多少页

输入格式 Input Format

输入文件的第一行包含两个整数：文件的总行数N（2≤N≤1000）和该书每一页所能包含的最多行数K（2≤K≤1000），两数中间用空格隔开。
输入文件的第二行包含：一个整数F（1≤F≤100），表示该书所包含的脚注总数。
接下来的F行每行包含两个用空格隔开的整数X和Y，表示正文的第X行包含一个脚注标记，该脚注标记对应的脚注需要Y行，脚注将按它们在文件中被引用的先后排序。
注意：对于所有的输入数据，问题总是有解的。

输出格式 Output Format

输出文件仅一行，一个整数，表示该书所需的最少页数。

Tip:第一、边界问题。第二、一行可能有多个注解。第三、最后那页需要判断。我的方法可以避免第二个错误：设置数组全部为1，然后读取注解后加到数组内，最后对照k，满了就页数+1.

#include <stdio.h>

int main(){
int i,n,k,f,page=0,sum=0,x,y,z[1000];
for (i=1;i<=1000;i++) z[i]=1;
scanf("%d%d",&n,&k);
scanf("%d",&f);
for (i=1;i<=f;i++){
scanf("%d%d",&x,&y);
z[x]+=y;
}
for (i=1;i<=n;i++){
sum+=z[i];
if (sum>k){
page++;
sum=z[i];
}
if (sum==k){
page++;
sum=0;
}
}
if (sum>0) page++;
printf("%d",page);
system("pause");
return 0;
}

描述 Description

给出一个小于2^32的正整数。这个数可以用一个32位的二进制数表示（不足32位用0补足）。我们称这个二进制数的前16位为“高位”，后16位为“低位”。将它的高低位交换，我们可以得到一个新的数。试问这个新的数是多少（用十进制表示）。
例如，数1314520用二进制表示为0000 0000 0001 0100 0000 1110 1101 1000（添加了11个前导0补足为32位），其中前16位为高位，即0000 0000 0001 0100；后16位为低位，即0000 1110 1101 1000。将它的高低位进行交换，我们得到了一个新的二进制数0000 1110 1101 1000 0000 0000 0001 0100。它即是十进制的249036820。

输入格式 Input Format

一个小于2^32的正整数

输出格式 Output Format

将新的数输出。

Tip:位运算，使用 "| 按位或"和"<< 左移"、">> 右移"来写程序，很简单就AC了。

位运算符C语言提供了六种位运算符："& 按位与" "| 按位或" "^ 按位异或" "~ 取反" "<< 左移" ">> 右移"

#include <stdio.h>

int main(){
unsigned x;
scanf("%lu",&x);
printf("%lu",(x<<16)|(x>>16));
system("pause");
return 0;
}

背景 Background

wind发明了一个好玩的游戏，叫小杉(lolanv)一起玩。
但小杉玩了十几盘，总是输，他想知道是不是从一开始他就注定要输。

描述 Description

这个游戏是这样的，wind先写下一排数。既然是一排，当然有首尾咯。
wind和小杉(lolanv)每次只能从这排数的头或尾取一个数。
最后谁取的数的和多，谁就赢了。如果两人的和一样多，先取者胜。

有天swgr看到他们俩在玩这个游戏，很好奇。
他想知道，在两人总是做出最优决策的情况下，谁能取得最终的胜利呢？

输入格式 Input Format

第一行为一个数k(k<=10)，表示有k组测试数据。
以下k组测试数据。
每组测试数据中，第一行仅有一个偶数n(0<n<=100000)
第二行也仅有一个数，0表示wind先取数，1表示小杉(lolanv)先取数
第三行有n个数，是wind给出的一排数。这n个数的绝对值均不超过1e6

输出格式 Output Format

对每组测试数据输出一行
表示在两人总是做出最优决策的情况下，
最终的胜利者的名字，即"wind"或"lolanv"（引号不输出）。

Tip:全部数字为偶数，则第一个数字为奇数位，最后一个数字为偶数位。如果先取者取奇数位上的数，后取者则不得不取偶数位上的数。因此只要预先计算奇数位上所有数的和与偶数位上所有数的和哪个大，则可一直取这个位上的数保证必胜。所以先手必胜...另外学会了使用 scanf("%*c%*[^\n]"); 可以跳过一行。跳过那行超大数据可以保证0ms完成。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <stdio.h>
 
int main(){
	int k,i,n,win;
	scanf("%d",&k);
	for (i=1;i<=k;i++){
		scanf("%d\n%d",&n,&win);	
		scanf("%*c%*[^\n]");
		if (win==0) printf("wind\n");
	 		else printf("lolanv\n");
	}
	//system("pause");
	return 0;			
}

描述 Description

CCC老师的生日是YY年MM月DD日，他想知道自己出生后第一万天纪念日的日期（出生日算第0天）。

输入格式 Input Format

从文件的第一行分别读入YY，MM，DD其中1949<=YY<=2006，日期绝对合法。

输出格式 Output Format

输出文件只有一行，即CCC老师生日第一万天以后的日期，格式为 “Y-M-D”。

Tip:疯狂的判断。。。尤其是闰年和平年对于二月的判断。。。充分利用&&和||可以简化程序。。。

另外需要注意括号配对的问题，我就因为这个卡了近半个小时。。。

#include <stdio.h>

int main(){
int y,m,d,i;
scanf("%d%d%d",&y,&m,&d);
for (i=1;i<=10000;i++){
d++;
if (d==29&&m==2&&(!((y%4==0&&y%100!=0)||(y%400==0)))){
d=1;
m++;
}
if (d==30&&m==2&&((y%4==0&&y%100!=0)||(y%400==0))){
d=1;
m++;
}
if (d==31&&(m==4||m==6||m==9||m==11)){
d=1;
m++;
}
if (d==32){
d=1;
m++;
}
if (m==13){
m=1;
y++;
}
}
printf("%d-%d-%d",y,m,d);
system("pause");
return 0;
}

描述 Description

我们要求找出具有下列性质数的个数(包含输入的自然数n):
先输入一个自然数n(n≤1000)，然后对此自然数按照如下方法进行处理
l·不作任何处理:
2·在它的左边加上一个自然数，但该自然数不能超过原数的一半;
3·加上数后，继续按此规则进行处理，直到不能再立生自然数为止。

Tip:一个奇怪的数列。。自己没研究出来，看的题解，估计把《组合数学》看了就明白了。。

1 2 2 4 4 6 6 10 10 14 14 20 20 26 26 36 36 46 46 60 60......s[i]=s[i div 2]+s[i-1]+1

我是用动态规划做的，虽然DFS也可以解决，不过DP最好。。。

#include <stdio.h>

int main(){
int i,j,n,x[1000]={0};
scanf("%d",&n);
x[0]=1;
x[1]=1;
for (i=2;i<=n;i++)
for (j=0;j<=i/2;j++)
x[i]=x[i]+x[j];
printf("%d",x[n]);
system("pause");
return 0;
}

描述 Description

已知：Sn= 1＋1／2＋1／3＋…＋1／n。显然对于任意一个整数K，当n足够大的时候，Sn大于K。
现给出一个整数K（1<=k<=15），要求计算出一个最小的n；使得Sn＞K。

输入格式 Input Format

输入 k

输出格式 Output Format

输出 n

Tip:注意Sn要用double型，倒数要用1.0做被除数。

#include <stdio.h>
#include <math.h>

#define pi 3.1415926

int i,n,t;
double c,r,length;
double x[101],y[101];

main(){
scanf("%d%lf",&n,&r);
for (i=1;i<=n;i++) scanf("%lf%lf",&x[i],&y[i]);
x[n+1]=x[1];
y[n+1]=y[1];
for (t=1;t<=n;t++) length+=sqrt(pow((x[t]-x[t+1]),2)+pow((y[t]-y[t+1]),2));
c=2*pi*r;
length+=c;
printf("%.2lf",length);
system("pause");
return 0;
}

描述 Description

有 N 堆纸牌，编号分别为 1，2，…, N。每堆上有若干张，但纸牌总数必为 N 的倍数。可以在任一堆上取若于张纸牌，然后移动。
移牌规则为：在编号为 1 堆上取的纸牌，只能移到编号为 2 的堆上；在编号为 N 的堆上取的纸牌，只能移到编号为 N-1 的堆上；其他堆上取的纸牌，可以移到相邻左边或右边的堆上。
现在要求找出一种移动方法，用最少的移动次数使每堆上纸牌数都一样多。

例如 N=4，4 堆纸牌数分别为：
①　9　②　8　③　17　④　6
移动3次可达到目的：
从 ③ 取 4 张牌放到 ④ （9 8 13 10） -> 从 ③ 取 3 张牌放到 ②（9 11 10 10）-> 从 ② 取 1 张牌放到①（10 10 10 10）。

输入格式 Input Format

N（N 堆纸牌，1 <= N <= 100）
A1 A2 … An （N 堆纸牌，每堆纸牌初始数，l<= Ai <=10000）

输出格式 Output Format

所有堆均达到相等时的最少移动次数。

Tip:贪心算法，首先计算平均值，然后从左往右扫描，不够平均值的从右边拿，次数+1；超过平均值的往右边放，次数+1。

#include <stdio.h>

int main(){
int n,i,move=0;
long a[101],num=0;
scanf("%d",&n);
for (i=0;i<n;i++){
scanf("%d",&a[i]);
num+=a[i];
}
num/=n;
for (i=0;i<n;i++){
if (a[i]>num){
a[i+1]+=(a[i]-num);
move++;
}
if (a[i]<num){
a[i+1]-=(num-a[i]);
move++;
}
}
printf("%d",move);
system("pause");
return 0;
}

描述 Description

津津上初中了。妈妈认为津津应该更加用功学习，所以津津除了上学之外，还要参加妈妈为她报名的各科复习班。另外每周妈妈还会送她去学习朗诵、舞蹈和钢琴。 但是津津如果一天上课超过八个小时就会不高兴，而且，上得越久就会越不高兴。假设津津不会因为其它事不高兴，并且她的不高兴不会持续到第二天。请你帮忙检 查一下津津下周的日程安排，看看下周她会不会不高兴；如果会的话，哪天最不高兴。

输入格式 Input Format

输入包括七行数据，分别表示周一到周日的日程安排。每行包括两个小于10的非负整数，用空格隔开，分别表示津津在学校上课的时间和妈妈安排她上课的时间。

输出格式 Output Format

输出包括一行，这一行只包含一个数字。如果不会不高兴则输出0，如果会则输出最不高兴的是周几(用1,2,3,4,5,6,7分别表示周一，周二，周三，周四，周五，周六，周日)。如果有两天或两天以上不高兴的程度相当，则输出时间最靠前的—天。

Tip:没难度，不说了。。。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <stdio.h>
 
int main()
{
	int i, k1, k2, num = 8, bad = 0;
	for (i = 1; i < 7; i++)
	{
		scanf("%d %d", &k1, &k2);
		if (k1 + k2 > num)
		{
			num = k1 + k2;
			bad = i;
		}
	}
	printf("%d", bad);
	//system("pause");
	return 0;	
}

描述 Description

某校大门外长度为L的马路上有一排树，每两棵相邻的树之间的间隔都是1米。我们可以把马路看成一个数轴，马路的一端在数轴0的位置，另一端在L的位置；数轴上的每个整数点，即0，1，2，……，L，都种有一棵树。
由于马路上有一些区域要用来建地铁。这些区域用它们在数轴上的起始点和终止点表示。已知任一区域的起始点和终止点的坐标都是整数，区域之间可能有 重合的部分。现在要把这些区域中的树（包括区域端点处的两棵树）移走。你的任务是计算将这些树都移走后，马路上还有多少棵树。

输入格式 Input Format

输入的第一行有两个整数：L（1 <= L <= 10000）和 M（1 <= M <= 100），L代表马路的长度，M代表区域的数目，L和M之间用一个空格隔开。接下来的M行每行包含两个不同的整数，用一个空格隔开，表示一个区域的起始点 和终止点的坐标。

输出格式 Output Format

输出包括一行，这一行只包含一个整数，表示马路上剩余的树的数目。

Tip:不是很难，如果方法对的话很容易过。设一个长度为L的大数组x，值全部为1。循环扫描，出现公路就将此处的x[i]设为0，然后对该数组进行求和即可。注意边界的取舍。

#include <stdio.h>

int main(){
int l,x[10000],m,i,j,x1,x2,num=0;
scanf("%d%d",&l,&m);
for (i=0;i<=l;i++) x[i]=1;
for (i=0;i<m;i++){
scanf("%d%d",&x1,&x2);
for (j=x1;j<=x2;j++) x[j]=0;
}
for (i=0;i<=l;i++) num+=x[i];
printf("%d",num);
system("pause");
return 0;
}

描述 Description

陶陶家的院子里有一棵苹果树，每到秋天树上就会结出10个苹果。苹果成熟的时候，陶陶就会跑去摘苹果。陶陶有个30厘米高的板凳，当她不能直接用手摘到苹果的时候，就会踩到板凳上再试试。
现在已知10个苹果到地面的高度，以及陶陶把手伸直的时候能够达到的最大高度，请帮陶陶算一下她能够摘到的苹果的数目。假设她碰到苹果，苹果就会掉下来。

输入格式 Input Format

输入包括两行数据。第一行包含10个100到200之间（包括100和200）的整数（以厘米为单位）分别表示10个苹果到地面的高度，两个相邻的整数之 间用一个空格隔开。第二行只包括一个100到120之间（包含100和120）的整数（以厘米为单位），表示陶陶把手伸直的时候能够达到的最大高度。

输出格式 Output Format

输出包括一行，这一行只包含一个整数，表示陶陶能够摘到的苹果的数目。

Tip:没难度，不说了。

#include <stdio.h>

int main(){
int i,max,num=0,h[10];
for (i=1;i<=10;i++)
scanf("%d",&h[i]);
scanf("%d",&max);
max+=30;
for (i=1;i<=10;i++)
if (max>=h[i]) num++;
printf("%d",num);
system("pause");
return 0;
}

描述 Description

津津的零花钱一直都是自己管理。每个月的月初妈妈给津津300元钱，津津会预算这个月的花销，并且总能做到实际花销和预算的相同。
为了让津津学习如何储蓄，妈妈提出，津津可以随时把整百的钱存在她那里，到了年末她会加上20％还给津津。因此津津制定了一个储蓄计划：每个月的月初，在 得到妈妈给的零花钱后，如果她预计到这个月的月末手中还会有多于100元或恰好100元，她就会把整百的钱存在妈妈那里，剩余的钱留在自己手中。
例如11月初津津手中还有83元，妈妈给了津津300元。津津预计11月的花销是180元，那么她就会在妈妈那里存200元，自己留下183元。到了11月月末，津津手中会剩下3元钱。
津津发现这个储蓄计划的主要风险是，存在妈妈那里的钱在年末之前不能取出。有可能在某个月的月初，津津手中的钱加上这个月妈妈给的钱，不够这个月的原定预算。如果出现这种情况，津津将不得不在这个月省吃俭用，压缩预算。
现在请你根据2004年1月到12月每个月津津的预算，判断会不会出现这种情况。如果不会，计算到2004年年末，妈妈将津津平常存的钱加上20％还给津津之后，津津手中会有多少钱。

输入格式 Input Format

输入包括12行数据，每行包含一个小于350的非负整数，分别表示1月到12月津津的预算。

输出格式 Output Format

输出包括一行，这一行只包含一个整数。如果储蓄计划实施过程中出现某个月钱不够用的情况，输出-X，X表示出现这种情况的第一个月；否则输出到2004年年末津津手中会有多少钱。

Tip:模拟就好了，但是需要注意不要忘记在计算存款＋利息后再+12月份手上剩余的钱；另外需要注意最后不能*0.2，要/5才行。。。因为*0.2以后结果会变成小数。。。

#include <stdio.h>

int main(){
int i;
long save=0,now=0,cost;
for (i=1;i<=12;i++){
now+=300;
scanf("%ld",&cost);
if (now-cost<0){
printf("%d",-i);
system("pause");
return 0;
}
now-=cost;
save+=now/100*100;
now%=100;

}
printf("%ld",now+save+save/5);
system("pause");
return 0;
}

背景 Background

化学不及格的ET无奈选择了文科。他必须硬着头皮准备一次又一次的文科考试。

描述 Description

在这一学期一共有n次文科考试，考试科目有4种，分别为政治、历史、地理和综合。每次考哪一科是不定的，因此在考试前ET不知道应该去复习哪 一科的功课。他希望能预测出下一次可能考的科目。于是，他收集到了以往的文科考试的资料。从以往的考试中，他发现了这样几个规律：

1.如果这次考的是政治，那么下一次一定会考历史；
2.如果这次考的是综合，那么下一次一定会考地理；
3.如果这次考的是历史，那么下一次要么考政治，要么考地理；
4.如果这次考的是地理，那么下一次要么考历史，要么考综合。

ET已经知道，本学期的第一次考试科目为政治。他打算拟定一个可以应对所有可能情况的应考复习计划。因此，他想知道，整个学期有多少种可能的考试科目安排满足以上规律。

输入格式 Input Format

一个正整数n，代表本学期总的考试次数。
输入数据保证n<=10000。

输出格式 Output Format

一个正整数，表示符合规律的科目安排方案的总数。
考虑到这个结果可能会很大，因此你只需要输出它mod 7654321的值即可。

Tip:不知道他们怎么看出来是Fibonacci数列的，以后发现这样的题得先推推前几项，然后不完全归纳。。。需要注意每次加的时候都除以mod 7654321，否则会越界。

下面是证明：

f(n)=a(n)+b(n)    a表示历史或地理(生成双科的) b表示政治或综合(生成单科)
a(n)=f(n-1)    无论单科还是双科都会生成一个双科
b(n)=a(n-1)    第N次的单科是第N-1次双科生成的
即 f(n)=a(n)+b(n)=f(n-1)+a(n-1)=f(n-1)+f(n-2)

#include <stdio.h>

int main(){
int n,i;
long x[10001];
scanf("%d",&n);
x[1]=1;
x[2]=1;
for (i=3;i<=n;i++) x[i]=(x[i-1]+x[i-2])%7654321;
printf("%d",x[n]);
system("pause");
return 0;
}

背景 Background

在Slyar的信息组里，Slyar1、Slyar2和Slyar3之间有着一种奇怪的债务关系：Slyar1欠了Slyar2一百块钱，Slyar2欠了Slyar3一百块钱，Slyar3欠了Slyar1一百块钱。

描述 Description

一天，三个人遇到了一起。由于他们都不够理智，一心想要回自己借出去的钱，于是互相之间追逐起来。最初，三个人分别站在一个边长为L正三角形的三个顶点上。某一个时刻，三个人同时开始以速度V匀速运动。他们运动的方向是这样的：每一个时刻，Slyar1运动的方向指向Slyar2，Slyar2运动的方向指向Slyar3，Slyar3运动的方向指向Slyar1，总之，每一个时刻，三个人都在尽快的接近各自欠自己债的人。最终，三个人都到达了同一个点上，并且通过和谈的方式解决了这一冲突。
honghong知道此事后，想写一篇报道，宣传这件事情。他想知道每个人走的路程的长度S，以及他们到达同一个点所需要的时间T。

输入格式 Input Format

输入文件有两行。
第一行为一个实数L（0<=L<=1E100）。
第二行为一个实数V（0<=V<=1E100）。

输出格式 Output Format

输出文件有两行。
第一行为一个实数S，保留一位小数。
第二行为一个实数T，保留一位小数。

Tip:纯粹的物理竞赛题，刚开始真蒙了，速度一样，在一个等边三角形上，就是走到中国队拿了世界杯也碰不到头呐。。。

后来想明白了，最重要的是一句话：“每一个时刻，三个人都在尽快的接近各自欠自己债的人”，也就是每个时刻他们的速度方向都指向欠钱的那个人，所以他们越绕圈子越小，最后在三角形的中心碰头……位移就是顶点到中心距离＝2/3*l

此题需要双精度double，而且需要使用%lf输出，因为精度问题交了4次才过。。。

#include <stdio.h>

int main(){
double l,v,s,t;
scanf("%lf",&l);
scanf("%lf",&v);
s=l*2.0/3.0; /* 注意精度，一定要加小数点 */
t=l/(1.5*v);
printf("%.1lf\n%.1lf",s,t);
system("pause");
return 0;
}

描述 Description

天下会评选一级弟子，最后评选结果神风堂有超过P%但不足Q%的人被评上了。现在给你P和Q，你要算出神风堂最少有多少人。

输入格式 Input Format

两个实数P，Q。用空格隔开。每个数最多有两位小数。0.00<=p<q<=99.99

输出格式 Output Format

神风堂最少的人数。

Tip:纯粹的穷举，但要注意读题目，是在p-q之间，不包括p-q，所以可以通过在p这边加上0.000001，在q这边减去0.000001 来解决，只要 (int)(i*n-0.000001)-(int)(i*m+0.000001)>=1 成立退出穷举，答案就出来了。

#include <stdio.h>

int main(){
int i;
float m,n;
scanf("%f %f",&m,&n);
m/=100;
n/=100;
for(i=1;;i++){
if((int)(i*n-0.000001)-(int)(i*m+0.000001)>=1) break;
}
printf("%d",i);
system("pause");
return 0;
}

描述 Description

某校的惯例是在每学期的期末考试之后发放奖学金。发放的奖学金共有五种，获取的条件各自不同：

1)  院士奖学金，每人8000元，期末平均成绩高于80分（>80），并且在本学期内发表1篇或1篇以上论文的学生均可获得；
2)  五四奖学金，每人4000元，期末平均成绩高于85分（>85），并且班级评议成绩高于80分（>80）的学生均可获得；
3)  成绩优秀奖，每人2000元，期末平均成绩高于90分（>90）的学生均可获得；
4)  西部奖学金，每人1000元，期末平均成绩高于85分（>85）的西部省份学生均可获得；
5)  班级贡献奖，每人850元，班级评议成绩高于80分（>80）的学生干部均可获得；

只要符合条件就可以得奖，每项奖学金的获奖人数没有限制，每名学生也可以同时获得多项奖学金。例如姚林的期末平均成绩是87分，班级评议成绩82分，同时他还是一位学生干部，那么他可以同时获得五四奖学金和班级贡献奖，奖金总数是4850元。

现在给出若干学生的相关数据，请计算哪些同学获得的奖金总数最高（假设总有同学能满足获得奖学金的条件）。

输入格式 Input Format

输入的第一行是一个整数N（1 <= N <= 100），表示学生的总数。接下来的N行每行是一位学生的数据，从左向右依次是姓名，期末平均成绩，班级评议成绩，是否是学生干部，是否是西部省份学生，以及发表的论文数。姓名是由大小写英文字母组成的长度不超过20的字符串（不含空格）；期末平均成绩和班级评议成绩都是0到100之间的整数（包括0和 100）；是否是学生干部和是否是西部省份学生分别用一个字符表示，Y表示是，N表示不是；发表的论文数是0到10的整数（包括0和10）。每两个相邻数据项之间用一个空格分隔。

输出格式 Output Format

输出包括三行，第一行是获得最多奖金的学生的姓名，第二行是这名学生获得的奖金总数。如果有两位或两位以上的学生获得的奖金最多，输出他们之中在输入文件中出现最早的学生的姓名。第三行是这N个学生获得的奖学金的总数。

Tip:注意读数据就好了，特别注意空格的处理，读分数的时候中间的空格要算上。

#include<stdio.h>

int main(){
int i,j,n,qm,py,lw,prize,max=0;
long total=0;
char a[20],name[20],xb,gb;
scanf("%d",&n);
for(i=1;i<=n;i++){
scanf("%s %d %d %c %c %d",a,&qm,&py,&gb,&xb,&lw);
prize=0;
if((qm>80)&&(lw>0)) prize+=8000;
if((qm>85)&&(py>80)) prize+=4000;
if(qm>90) prize+=2000;
if((qm>85)&&(xb=='Y')) prize+=1000;
if((py>80)&&(gb=='Y')) prize+=850;
total+=prize;
if(prize>max){
max=prize;
for(j=0;j<20;j++) name[j]=a[j];
}
}
printf("%s\n%d\n%ld",name,max,total);
system("pause");
return 0;
}

背景 Background

平面上有N个圆柱形的大钉子，半径都为R,所有钉子组成一个凸多边形。
现在你要用一条绳子把这些钉子围起来，绳子直径忽略不计。

描述 Description

求出绳子的长度

输入格式 Input Format

第1行两个数：整数N(1<=N<=100)和实数R。
接下来N行按逆时针顺序给出N个钉子中心的坐标
坐标的绝对值不超过100。

输出格式 Output Format

一个数，绳子的长度，精确到小数点后2位。

Tip:算一个木桩的周长，再用两点间距离公式算剩下的长度就行了，需要注意的是不要忘记把最后一个点和第一个点之间的线段加上去。还需要注意精度问题。

#include <stdio.h>
#include <math.h>

#define pi 3.1415926

int i,n,t;
double c,r,length;
double x[101],y[101];

main(){
scanf("%d%lf",&n,&r);
for (i=1;i<=n;i++) scanf("%lf%lf",&x[i],&y[i]);
x[n+1]=x[1];
y[n+1]=y[1];
for (t=1;t<=n;t++) length+=sqrt(pow((x[t]-x[t+1]),2)+pow((y[t]-y[t+1]),2));
c=2*pi*r;
length+=c;
printf("%.2lf",length);
system("pause");
return 0;
}

背景 Background

BNUEP风靡一款智力游戏，也就是数独（九宫格），先给你一个数独，并需要你验证是否符合规则。

描述 Description

具体规则如下:
每一行都用到1,2,3,4,5,6,7,8,9，位置不限，
每一列都用到1,2,3,4,5,6,7,8,9，位置不限，
每3×3的格子（共九个这样的格子）都用到1,2,3,4,5,6,7,8,9，位置不限，
游戏的过程就是用1,2,3,4,5,6,7,8,9填充空白，并要求满足每行、每列、每个九宫格都用到1,2,3,4,5,6,7,8,9。
如下是一个正确的数独:
5 8 1 4 9 3 7 6 2
9 6 3 7 1 2 5 8 4
2 7 4 8 6 5 9 3 1
1 2 9 5 4 6 3 7 8
4 3 6 1 8 7 2 9 5
7 5 8 3 2 9 1 4 6
8 9 2 6 7 1 4 5 3
6 1 5 9 3 4 8 2 7
3 4 7 2 5 8 6 1 9

输入格式 Input Format

输入n个数独，你来验证它是否违反规则.
第一行为数独个数，第二行开始为第一个数独，之后为第二个，至第n个.
注意！每个数独之间有一个回车隔开!

输出格式 Output Format

若正确则输出”Right”若不正确则输出”Wrong” 输出一个换一行.

Tip:哎，这题真是跌宕起伏啊，不想考察每个数字使用的次数，那样太麻烦，于是就想到了每行每列每3*3小格的数字和为45，这样做完WA了，检查后发现不能边读入边判断，因为那样break后下次还是从中断的地方开始读，所以只能先读完再判断。可是再次WA了，考虑了一会恍然大悟，有数字全部都是5的情况。。。我XXXX

#include <stdio.h>

int sign,a[10][10];

void calc(int x)
{
int s1=0,s2=0,s3=0,i,j;
for(i=x;i<=x+2;i++)
{
for(j=1;j<=3;j++) s1+=a[i][j];
for(j=4;j<=6;j++) s2+=a[i][j];
for(j=7;j<=9;j++) s3+=a[i][j];
}
if((s1!=45)||(s2!=45)||(s3!=45)) sign=0;
}

int main()
{
int i,j,n,sum;
scanf("%d",&n);
while(n--)
{
sign=1;
for(i=1;i<=9;i++)
{
for(j=1;j<=9;j++)
{
scanf("%d",&a[i][j]);
}
}
for(i=1;i<=9;i++)
{
sum=0;
for(j=1;j<=9;j++)
{
if(a[i][j]==5) sum++;
}
if (sum>1)
{
sign=0;
break;
}
}
if(sign)
{
for(i=1;i<=9;i++)
{
sum=0;
for(j=1;j<=9;j++) sum+=a[i][j];
if(sum!=45)
{
sign=0;
break;
}
}
}
if(sign)
{
for(j=1;j<=9;j++)
{
sum=0;
for(i=1;i<=9;i++) sum+=a[i][j];
if(sum!=45)
{
sign=0;
break;
}
}
}
if(sign) calc(1);
if(sign) calc(4);
if(sign) calc(7);
if(sign) printf("Right\n");
else printf("Wrong\n");
scanf("");
}
system("pause");
return 0;
}

描述 Description

输入一个自然数n(n<10^2000)，表示1到n共n个自然数排成一列，你要在每一个数前添上+或-,要使得添加符号后这个代数式的值最小且非负.

输入格式 Input Format

一个数，n.

输出格式 Output Format

一个数，即最小非负值。

Tip:n=4时,1~4的数可以这样添加正负号:-1+2+3-4或+1-2-3+4,即-(n-3)+(n-2)+(n-1)-n或+(n-3)-(n-2)-(n-1)+n这样每四个一循环,值为0。而100的倍数必能整除4，搞定。

#include <stdio.h>
#include <string.h>

int main(){
char a[20000]={0};
int n;
scanf("%s",&a);
n=a[strlen(a)-1]+a[strlen(a)-2]*10;
n%=4;
if(n==1||n==2) printf("1\n");
else printf("0\n");
system("pause");
return 0;
}

描述 Description

这个数列是这样的：
0,1,3,2,6,7,5,4,12,13,15,14,10,11,9,8,24,25,27,26,30,31……
先仔细研究一下这个数列的规律。
现在他们请你编写一个程序，要求找出数n在此数列中的位置序号k。

输入格式 Input Format

输入数据只有一行，为数 n (n<=2^31-1)

输出格式 Output Format

输出数据只有一行，为数k。

Tip:传说中的格雷码。。。

二进制-->格雷码：从最右边一位起，依次将每一位与左边一位异或(^)，作为当前格雷码的值，最左边一位不变(相当于左边是0)

格雷码-->二进制：从左边第二位起，将每位与左边一位二进制值异或(^)，作为当前二进制的值，最左边一位不边(相当于左边是0)

#include <stdio.h>

int fuck(int x){
if (x==0) return 0;
else return x^fuck(x/2);
}

int main(){
int n;
scanf("%d",&n);
printf("%d",fuck(n)+1);
system("pause");
return 0;
}

描述 Description

将整数n分成k份，且每份不能为空，任意两份不能相同(不考虑顺序)。
例如：n=7，k=3，下面三种分法被认为是相同的。
1,1,5; 1,5,1; 5,1,1;
问有多少种不同的分法。

输入格式 Input Format

输入n，k (6<n<=200，2<=k<=6)

输出格式 Output Format

一个整数，即不同的分法。

Tip:把i分成j份：

如果最小数是1，则总数为f[i-1][j-1]；

如果最小数大于1，则把每个数减一，得f[i-j][j]；

所以f[i][j]=f[i-j][j]+f[i-1][j-1]

#include <stdio.h>

int main(){
int n,k,i,j,f[201][101]={0};
scanf("%d%d",&n,&k);
f[0][0]=1;
for(i=1;i<=n;i++)
for(j=1;j<=k;j++)
if(i>=j) f[i][j]=f[i-1][j-1]+f[i-j][j];
else f[i][j]=f[i-1][j];
printf("%d",f[n][k]);
system("pause");
return 0;
}

描述 Description

BNUEP的同学们为了庆祝春节，准备排练一场舞会。
明显……交谊舞是2个人跳的，而且一男一女  -____-||||。
由于交谊舞之前的节目安排，所有的表演者都站成了一排。这一排人的顺序满足2点：
①对于一对舞伴男生站在女生的左边。
②任何一对舞伴之间,要么没有人，要么就有若干对舞伴。
排得过于整齐导致那些要表演交谊舞的人都没办法看到自己的舞伴，怎么办类…….
所幸的是，BNUEP的女生比男生聪明得多。她们知道自己左边有几个男生。
现在就请你再告诉这些女生，她们的舞伴距离她们多远（即包括那个男生，一共有多少男生夹在他们之间）。

输入格式 Input Format

第一行为一个数n，表示参与跳交谊舞的女生个数。
第二行n个数，从左到右表示这n个女生左边分别有多少个男生。

输出格式 Output Format

一排n个数，行末无空格。表示n个女生与其舞伴的距离。

Tip:设置一个男生的数组，全部置为0，从左边开始，每个女生在她左边离她最近的非0男生，就是她的舞伴。 然后把那个男生置1，继续找下一个女生。注意数据规模。

#include <stdio.h>

int main(){
int i,j,n,b[20000]={0},g[1501];
scanf("%d",&n);
for (i=1;i<=n;i++){
scanf("%d",&g[i]);
for (j=g[i];j>=1;j--)
if (!b[j]){
b[j]=1;
printf("%d ",g[i]-j+1);
break;
}
}
system("pause");
return 0;
}

描述 Description

小杉终于进入了天堂。他看到每个人都带着一双隐形翅膀，他也想要。
天使告诉小杉，每只翅膀都有长度，两只翅膀的长度之比越接近黄金分割比例，就越完美。
现在天使给了小杉N只翅膀，小杉想挑出一对最完美的。

输入格式 Input Format

每组测试数据的
第一行有一个数N(2<=N<=30000)
第二行有N个不超过1e5的正整数，表示N只翅膀的长度。
20%的数据N<=100
你可以认为黄金分割比就是0.6180339887498949

输出格式 Output Format

对每组测试数据输出两个整数，分两行，表示小杉挑选出来的一对翅膀。
注意，比较短的在前，如果有多对翅膀的完美程度一样，请输出最小的一对。

Tip:快排+贪心。精度、精度、精度！一定要注意精度问题，还有就是整型相除的结果是整型，要变成实型才可以。。。因为精度又WA了N次。。。

#include <stdio.h>

#define gold 0.6180339887498949

void qsort(long s[],int l,int r){
int i,j,x;
if(l<r){
i=l;
j=r;
x=s[i];
while(i<j){
while(i<j&&s[j]>x) j--;
if(i<j) s[i++]=s[j];
while(i<j&&s[i]<x) i++;
if(i<j) s[j--]=s[i];
}
s[i]=x;
qsort(s,l,i-1);
qsort(s,i+1,r);
}
}

int main(){
long n,a[30001],i,p=1,q=2,x,y;
double min=100;
scanf("%d",&n);
for (i=1;i<=n;i++) scanf("%d",&a[i]);
qsort(a,1,n);
while(q<=n){
if (fabs(a[p]*1.0/a[q]-gold)<min){
x=a[p];
y=a[q];
min=fabs(a[p]*1.0/a[q]-gold);
}
if (a[p]*1.0/a[q]<gold) p++;
else q++;
}
printf("%d\n%d\n",x,y);
system("pause");
return 0;
}

描述 Description

华华通过以下方式进行分析，首先将比赛每个球的胜负列成一张表，然后分别计算在11分制和21分制下，双方的比赛结果（截至记录末尾）。
比如现在有这么一份记录，（其中W表示华华获得一分，L表示华华对手获得一分）：
WWWWWWWWWWWWWWWWWWWWWWLW
在11分制下，此时比赛的结果是华华第一局11比0获胜，第二局11比0获胜，正在进行第三局，当前比分1比1。而在21分制下，此时比赛结果是华华第一局21比0获胜，正在进行第二局，比分2比1。如果一局比赛刚开始，则此时比分为0比0。
你的程序就是要对于一系列比赛信息的输入（WL形式），输出正确的结果。

输入格式 Input Format

每个输入文件包含若干行字符串（每行至多20个字母），字符串有大写的W、L和E组成,也许中间有若干个空格。其中E表示比赛信息结束，程序应该忽略E之后的所有内容,E后面可能有干扰文字。

输出格式 Output Format

输出由两部分组成，每部分有若干行，每一行对应一局比赛的比分（按比赛信息输入顺序）。其中第一部分是11分制下的结果，第二部分是21分制下的结果，两部分之间由一个空行分隔。

Tip:11分制是指，选手双方谁先取得11分，就获得一局比赛的胜利；而21分制指，选手双方谁先取得21分，可以嬴得一局比赛的胜利。当某人分数达到 11（11分制）或21（21分制下），但双方的得分差小于两分时（比如21分制下21：20），则比赛继续进行，直到双方差距等于两分为止。注意数据规模，数组要开到10万以上，另外注意特殊情况的输出。

#include <stdio.h>

int main(){
char x,s[1000000];
int i,n=1,w,l;
for(;;){
scanf("%c",&x);
if (x=='E') break;
if (x=='W'||x=='L'){
s[n]=x;
n++;
}
}
w=0;
l=0;
for (i=1;i<=n-1;i++){
if (s[i]=='W') w++;
if (s[i]=='L') l++;
if ((w>=11||l>=11)&&abs(w-l)>1){
printf("%d:%d\n",w,l);
w=0;
l=0;
}
}
printf("%d:%d\n\n",w,l);
w=0;
l=0;
for (i=1;i<=n-1;i++){
if (s[i]=='W') w++;
if (s[i]=='L') l++;
if ((w>=21||l>=21)&&abs(w-l)>1){
printf("%d:%d\n",w,l);
w=0;
l=0;
}
}
printf("%d:%d\n",w,l);
system("pause");
return 0;
}

描述 Description

输入两个自然数m,n 1<=n<=20，1<=m<=n!
输出n个数的第m种全排列。
如 ：
输入 3 1
输出 1 2 3

输入格式 Input Format

在一行中输入n m

输出格式 Output Format

一个数列,既n个数的第m种排列
每两个数之间空1格

Tip:使用传说中的构造法，纯数学问题。因为数据很大，所以要使用long long类型，我一开始用long没过，换成unsigned long还没过，改成long long才过了。。。汗。。。

#include <stdio.h>

long long jc(int n){
long long x=1;
while (n>0)
x*=(n--);
return x;
}

int main(){
long long s[21];
int i,j,n,m,total,now,b[21]={0};
scanf("%d%d",&n,&m);
for (i=1;i<=n;i++){
total=((m-1)/jc(n-i)+1)%(n-i+1);
if (total==0) total=n-i+1;
now=0;
for (j=1;j<=n;j++){
if (!b[j]) now++;
if (now==total) break;
}
s[i]=j;
b[j]=1;
}
for (i=1;i<=n;i++) printf("%d ",s[i]);
system("pause");
return 0;
}

描述 Description

N位同学站成一排，音乐老师要请其中的(N-K)位同学出列，使得剩下的K位同学排成合唱队形。
合唱队形是指这样的一种队形：设K位同学从左到右依次编号为1，2…，K，他们的身高分别为T1，T2，…，TK，  则他们的身高满足T1<...<Ti>Ti+1>…>TK(1<=i<=K)。
你的任务是，已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。

输入格式 Input Format

输入的第一行是一个整数N(2<=N<=100)，表示同学的总数。第一行有n个整数，用空格分隔，第i个整数Ti(130<=Ti<=230)是第i位同学的身高(厘米)。

输出格式 Output Format

输出包括一行，这一行只包含一个整数，就是最少需要几位同学出列。

Tip:最长上升序列，正着一次，反着一次，总数减正反和的最大值。N-max{f[k]+g[k]|K∈[0..n-1]}+1 。

#include <stdio.h>

int main(){
int a[101]={0},l[101]={0},r[101]={0},n,i,j,max=0,p;
scanf("%d",&n);
for (i=1;i<=n;i++)
scanf("%d",&a[i]);
for (i=1;i<=n;i++){
p=1;
for (j=0;j<i;j++)
if ((a[i]>a[j])&&(l[j]+1>p)) p=l[j]+1;
l[i]=p;
}
for (i=n;i>0;i--){
p=1;
for (j=n+1;j>1;j--)
if ((a[i]>a[j])&&(r[j]+1>p)) p=r[j]+1;
r[i]=p;
}
for (i=1;i<=n;i++)
if (max<l[i]+r[i]-1) max=l[i]+r[i]-1;
printf("%d",n-max);
system("pause");
return 0;
}

描述 Description

元旦快到了，校学生会让乐乐负责新年晚会的纪念品发放工作。为使得参加晚会的同学所获得 的纪念品价值相对均衡，他要把购来的纪念品根据价格进行分组，但每组最多只能包括两件纪念品， 并且每组纪念品的价格之和不能超过一个给定的整数。为了保证在尽量短的时间内发完所有纪念品，乐乐希望分组的数目最少。

你的任务是写一个程序，找出所有分组方案中分组数最少的一种，输出最少的分组数目。

【限制】

50%的数据满足: 1 <=n <= 15

100%的数据满足: 1 <= n <= 30000， 80 <= W <= 200

输入格式 Input Format

第1行包括一个整数w，为每组纪念品价格之和的上眼= 第2行为一个整数n，表示购来的纪念品的总件数G

第3-n+2行每行包含一个正整数Pi (5 <= Pi <= w3)w表示所对应纪念品的价格。

输出格式 Output Format

仅1行，包含一个整数， ep最少的分组数目合

Tip:一开始桶排+贪心，后面的数据不是0ms通过，不爽。后来换成快排+贪心(左右扫描相加)，不要时间AC，爽了。。。

#include <stdio.h>

void qsort(unsigned long s[],unsigned long l,unsigned long r){
unsigned long i,j,x;
if(l<r){
i=l;
j=r;
x=s[i];
while(i<j){
while(i<j&&s[j]>x) j--;
if(i<j) s[i++]=s[j];
while(i<j&&s[i]<x) i++;
if(i<j) s[j--]=s[i];
}
s[i]=x;
qsort(s,l,i-1);
qsort(s,i+1,r);
}
}

int main(){
unsigned long i,j,w,n,total=0,p[30001];
scanf("%ld",&w);
scanf("%ld",&n);
for (i=1;i<=n;i++) scanf("%ld",&p[i]);
qsort(p,1,n);
j=n;
for (i=1;i<=j;){
if (p[i]+p[j]<=w){
total++;
i++;
j--;
}
else{
total++;
j--;
}
}
if (i==j) total++;
printf("%ld",total);
system("pause");
return 0;
}

描述 Description

输入二个正整数x0,y0(2≤x0≤100000，2≤y0≤1000000)，求出满足下列条件的P、Q的个数。
条件:
1.P、Q是正整数
2.要求P、Q以xO为最大公约数，以yO为最小公倍数。
试求，满足条件的所有可能的两个正整数的个数。

输入格式 Input Format

两个正整数

输出格式 Output Format

满足条件的所有可能的两个正整数的个数

Tip:我是枚举的，但利用了"两数乘积=最大公约数*最小公倍数"这个公式和碾转相减法求最大公约数，注意检验最大公约数前要先判断两个数是否合理。有更好的方法是寻找两数的质因子数，但是我数学不好，不太理解呵呵~

#include <stdio.h>

int gcd(int a,int b){
while(a!=b){
if(a>b) a=a-b;
if(a<b) b=b-a;
}
return a;
}

int main(){

long total=0,x,y,x0,y0;
scanf("%ld%ld",&x0,&y0);
for (x=2;x<=y0;x++)
if ((x%x0==0)&&(y0%x==0)){
y=x0*y0/x;
if (x0==gcd(x,y)) total++;
}
printf("%ld",total);
system("pause");
return 0;
}

描述 Description

棋盘上A点有一个过河卒，需要走到目标B点。卒行走的规则：可以向下、或者向右。同时在棋盘上C点有一个对方的马，该马所在的点和所有跳跃一步可达的点称为对方马的控制点。因此称之为“马拦过河卒”。
棋盘用坐标表示，A点(0, 0)、B点(n, m)(n, m为不超过15的整数)，同样马的位置坐标是需要给出的。现在要求你计算出卒从A点能够到达B点的路径的条数，假设马的位置是固定不动的，并不是卒走一步马走一步。

输入格式 Input Format

一行四个数据，分别表示B点坐标和马的坐标。

输出格式 Output Format

一个数据，表示所有的路径条数。

Tip:动态规划，说是递推也行，到达某点的路径数等于到达它的上、左两点的路径数之和

F[0,0]=1
F[i,j]=0　　　　　　　　    {m[x,y]=1}
F[i,0]=F[i-1,0]　　　　　　{i>0,m[x,y]=0}
F[0,j]=F[0,j-1]　　　　　　{j>0,m[x,y]=0}
F[i,j]=F[i-1,j] + F[i,j-1]      {i>0,j>0,m[x,y]=0}

#include <stdio.h>

int main(){
int i,j,bx,by,mx,my;
long m[21][21]={0},f[21][21]={0};
scanf("%d%d%d%d",&bx,&by,&mx,&my);
m[mx][my]=1;
m[mx+1][my+2]=1;
m[mx+2][my+1]=1;
m[mx+2][my-1]=1;
m[mx+1][my-2]=1;
m[mx-1][my-2]=1;
m[mx-2][my-1]=1;
m[mx-2][my+1]=1;
m[mx-1][my+2]=1;
f[0][0]=1;
for (i=1;i<=bx;i++) if(m[i][0]==0) f[i][0]=f[i-1][0];
for (j=1;j<=by;j++) if(m[0][j]==0) f[0][j]=f[0][j-1];
for(i=1;i<=bx;i++)
for(j=1;j<=by;j++){
if (m[i][j]) continue;
f[i][j]=f[i-1][j]+f[i][j-1];
}
printf("%ld",f[bx][by]);
system("pause");
return 0;
}

描述 Description

在高为 H 的天花板上有 n 个小球，体积不计，位置分别为 0，1，2，…．n-1。在地面上有一个小车（长为 L，高为 K，距原点距离为 S1）。已知小球下落距离计算公式为 d＝1/2*g*(t^2)，其中 g=10，t 为下落时间。地面上的小车以速度 V 前进。
小车与所有小球同时开始运动，当小球距小车的距离 <= 0.00001 时，即认为小球被小车接受（小球落到地面后不能被接受）。
请你计算出小车能接受到多少个小球。

输入格式 Input Format

输人：
H，S1，V，L，K，n （l<=H，S1，V，L，K，n <=100000）

输出格式 Output Format

小车能接受到的小球个数。

Tip:纯物理题，需要细心，再细心，注意细节。。。

#include <stdio.h>
#include <math.h>

#define g 10.0
#define wc 0.00001

int main(){
float h,s1,v,l,k,down2,down1,go1,go2;
long n,sum=0;
scanf("%f%f%f%f%f%ld",&h,&s1,&v,&l,&k,&n);
down1=sqrt(2*h/g);
down2=sqrt(2*(h-k)/g);
go1=s1-v*down1;
go2=s1-v*down2+l;
if (go1<0) go1=0;
if (go2>n-1) go2=n-1;
if (go1-(n-1)>wc||-go2>wc) sum=0;
else{
if (fabs(go1-(int)go1<=wc))
l=(int)go1;
else
l=(int)go1+1;
sum=(int)go2-l+1;
}
printf("%d",sum);
system("pause");
return 0;
}

背景 Background

怪盗基德 VS OIBH
第三话

描述 Description

怪盗基德第三次来到熟悉的OIBH总部。屡屡失败的OIBH这次看守的是The Eye of Moon。还是那个
房间，还是那扇门，不同的是OIBH对密码锁进行了改进。这次屏幕上只显示一个数n。
密码生成方法：设集合A中A={1,2,...,n}，B为A子集。对于B中任意一个元素x，2x均不在集合B中。
B中元素数目最大值即为密码。

输入格式 Input Format

一行，一个整数n(1<=n<=maxlongint)

输出格式 Output Format

只有一个整数m，表示B中元素最大值。

Tip:自己拿笔写一写就出来了。。。奇数全部可以，奇数的2倍不行，奇数的4倍又可以。。。

#include <stdio.h>

int calc(int x){
if (x==0) return 0;
else return (x+1)/2+calc(x/4);
}

int main(){
int n;
scanf("%d",&n);
printf("%d",calc(n));
system("pause");
return 0;
}