蓝桥杯往届真题及基本练习

蓝桥杯往届真题及基本练习（正在做）

2.等差素数列

题目：

2,3,5,7,11,13,…是素数序列。
类似：7,37,67,97,127,157 这样完全由素数组成的等差数列，叫等差素数数列。
上边的数列公差为30，长度为6。
2004年，格林与华人陶哲轩合作证明了：存在任意长度的素数等差数列。这是数论领域一项惊人的成果！有这一理论为基础，请你借助手中的计算机，满怀信心地搜索：
长度为10的等差素数列，其公差最小值是多少？

输入与输出：

输入：无
输出：一个整数（答案是210）

代码：

//暴力枚举
//利用一个数组记录，把是素数的在数组中用1表示出来
#include<stdio.h>
#include<string.h>
int a[10010];
int flag,k=0,j,m;
int main()
{
	a[2]=1;
	for(int i=3;i<=10000;i++)
	{
		for(j=2;j<i;j++)
		{
			if(i%j==0)
			break;
		}
		if(i==j)
		a[i]=1;
	}
	
	for(int i=1;i<=10000;i++)
	{
		for(int j=1;j<10000;j++)
		{
			flag=0;
			m=i;
			while(a[m]==1)
			{
				m+=j;
				flag++;
				if(flag==10)
				{
					printf("%d",j);
					return 0;
				}
			}
		}
	}
	return 0;
}

3.冒泡排序

题目：

冒泡排序是一种简单的排序算法。它重复地走访过要排序的元素，依次比较相邻两个元素，如果他们的顺序错误就把他们调换过来，直到没有元素再需要交换，排序完成。这个算法的名字由来是因为越小(或越大)的元素会经由交换慢慢“浮”到数列的顶端。

冒泡排序算法的运作如下：
　　1.比较相邻的元素，如果前一个比后一个大，就把它们两个调换位置。
　　2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
　　3.针对所有的元素重复以上的步骤，除了最后一个。
　　4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
　　
输入与输出：

输入：
输入有2行，第一行是一个整数n,表示第2行会有n个整数。
输出：
输出对第2行的n个整数每趟选择排序的结果。

样例输入：
8
75 23 64 32 54 91 89 17
样例输出：
23 64 32 54 75 89 17 91
23 32 54 64 75 17 89 91
23 32 54 64 17 75 89 91
23 32 54 17 64 75 89 91
23 32 17 54 64 75 89 91
23 17 32 54 64 75 89 91
17 23 32 54 64 75 89 91

代码：

//设置一个flag检查一遍是否还有交换发生
//没有交换发生则说明已经有序
#include<stdio.h>
#include<string.h> 
int n;
int a[10000];
bool flag;
void swap(int *a,int *b)
{
	int t;
	t=*a;
	*a=*b;
	*b=t;
}
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]); 
	}
	for(int i=n;i>1;i--)
	{
		flag=true;
		for(int j=1;j<i;j++)
		{
			if(a[j]>a[j+1])
			{
				swap(&a[j],&a[j+1]);
				flag=false;
			}
		}
		if(flag)
		break;
		for(int j=1;j<=n;j++)
		{
			printf("%d ",a[j]);
		}
		printf("\n");
	}
	return 0;
}

4.K倍区间

题目：

给定一个长度为N的数列，A1, A2, … AN，如果其中一段连续的子序列Ai, Ai+1, … Aj(i <= j)之和是K的倍数，我们就称这个区间[i, j]是K倍区间。

你能求出数列中总共有多少个K倍区间吗？

输入与输出：

输入：
第一行包含两个整数N和K。(1 <= N, K <= 100000)
以下N行每行包含一个整数Ai。(1 <= Ai <= 100000)
输出：
输出一个整数，代表K倍区间的数目。

样例输入：
5 2
1
2
3
4
5
样例输出：
6

代码：

//注意避免重复运算
#include<stdio.h>
int n,k,a[100010];
int main()
{
	int num=0;
	scanf("%d%d",&n,&k);
	for(int i=1;i<=n;i++)
		scanf("%d",&a[i]);
	for(int i=1;i<=n;i++)
	{
		int sum=0;
		for(int j=i;j>=1;j--)
		{
			sum+=a[j];
			if(sum%k==0)
			num++;
		}
	}
	printf("%d",num);
	return 0;
}

5.数字三角形

题目：

输入一个正整数n，输出n行数字三角形。其中，第1行为数字1，第2行为数字23，第3行为数字456，第4行为数字7890，第5行为数字12345，…

输入与输出：

输入：
一行一个正整数n，1<=n<=100
输出：
n行的数字三角形

样例输入：
4
样例输出：
1
23
456
7890

代码：

//需要注意的一点是数字是循环使用的
//所以数组里面是k++%10来输出
/*
例如：
10
1
23
456
7890
12345
678901
2345678
90123456
789012345
6789012345
*/
#include<stdio.h>
#include<string.h> 
int n;
int a[10]={1,2,3,4,5,6,7,8,9,0};
int main()
{
	scanf("%d",&n);
	int k=0;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=i;j++)
		{
			printf("%d",a[k++%10]);
		}
		printf("\n");
	}
	return 0;
}

6.设计函数，判断某年份是否为闰年。

题目：

设计函数，判断某年份是否为闰年。要求函数原型如下：

                bool  IsLeapYear(int);

输入与输出：

输入：
年份
输出：
是闰年/不是闰年

样例输入：
2016
2019
样例输出：
Is the leap year
Not leap year

代码：

//闰年能被4整除但是不能被100整除或者能被400整除
#include<stdio.h>
#include<string.h> 
int n;
bool IsLeapYear(int a)
{
	if((a%4==0&&a%100!=0)||a%400==0)
		return true;
	return false;
}
int main()
{
	scanf("%d",&n);
	if(IsLeapYear(n))
		printf("Is the leap year");
	else
		printf("Not leap year");
	return 0;
}

8.递归：爬楼梯

题目：

小明爬楼梯，他可以每次走1级或者2级，输入楼梯的级数，求不同的走法数。

例如：楼梯一共有3级，他可以每次都走一级，或者第一次走一级，第二次走两级；也可以第一次走两级，第二次走一级，一共3种方法。

输入与输出：

输入
输入包含若干行正整数，第一行正整数K代表数据组数；后面K行，每行包含一个正整数N，代表楼梯级数，1 <= N <= 30
输出
不同的走法数，每一行输入对应一行输出

样例输入
3
5
8
10
样例输出
8
34
89

代码：

//递归
//在递归的基础上设置一个数组来记录已经计算过的值
//避免重复计算，能够提高时间
#include<stdio.h>
#include<string.h> 
int n,m;
int p[50];
int f(int a)
{
	if(p[a]!=0)
		return p[a];
	p[a]=f(a-1)+f(a-2);
	return p[a];
}
int main()
{
	scanf("%d",&n);
	p[1]=1;
	p[2]=2;
	while(n--)
	{
		scanf("%d",&m);
		printf("%d\n",f(m));
	}
	return 0;
}

优化的时间：
（上面那个是用数组记录）

9.十进制转化为二进制

题目：

进制之间的转换

输入与输出：

输入：
一个正整数
输出：
对应的二进制

样例输入：
9
样例输出：
1001

代码：

//十进制转二进制利用除法+数组
//最后注意逆序输出
#include<stdio.h>
int a[100010];
int main()
{
	int b,i=0;
	scanf("%d",&b);
	while(b)
	{
		a[i++]=b%2;
		b=b/2;
	}
	for(int j=i-1;j>=0;j--)
		printf("%d",a[j]);
	return 0;
}

10.日期问题

题目：

小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在1960年1月1日至2059年12月31日。令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，有采用月/日/年的，还有采用日/月/年的。更加麻烦的是，年份也都省略了前两位，使得文献上的一个日期，存在很多可能的日期与其对应。
比如02/03/04，可能是2002年03月04日、2004年02月03日或2004年03月02日。
给出一个文献上的日期，你能帮助小明判断有哪些可能的日期对其对应吗？

输入与输出：

样例输入：
02/03/04
样例输出：
2002-03-04
2004-02-03
2004-03-02

代码：

//枚举+条件判断
#include<stdio.h>
#include<string.h>
char a1,a2,b1,b2,c1,c2;
struct node{
	int year;
	int month;
	int day;
} a[10];
void swap(int i,int j)
{
	a[0]=a[i];
	a[i]=a[j];
	a[j]=a[0];
}
void scan()
{
	a[1].year=1900+(a1-'0')*10+(a2-'0');
	a[2].year=2000+(a1-'0')*10+(a2-'0');
	for(int i=1;i<=2;i++)
	{
		a[i].month=(b1-'0')*10+(b2-'0');
		a[i].day=(c1-'0')*10+(c2-'0');
	}
	a[3].year=1900+(c1-'0')*10+(c2-'0');
	a[4].year=2000+(c1-'0')*10+(c2-'0');
	for(int i=3;i<=4;i++)
	{
		a[i].month=(a1-'0')*10+(a2-'0');
		a[i].day=(b1-'0')*10+(b2-'0');
	}
	a[5].year=1900+(c1-'0')*10+(c2-'0');
	a[6].year=2000+(c1-'0')*10+(c2-'0');
	for(int i=5;i<=6;i++)
	{
		a[i].day=(a1-'0')*10+(a2-'0');
		a[i].month=(b1-'0')*10+(b2-'0');
	}
}
void check()
{
	for(int i=1;i<=6;i++)
	{
		if(a[i].year>2059||a[i].year<1960)
		{
			a[i].year=0;
		}
		
		if(a[i].month>12||a[i].month<=0)
			a[i].year=0;
			
		if((a[i].month==2&&(a[i].day>29||a[i].day<=0))&&(a[i].year%400==0||(a[i].year%4==0&&a[i].year%100!=0)))
			a[i].year=0;
		else if(a[i].month==2&&(a[i].day>28||a[i].day<=0))
			a[i].year=0;
		else if((a[i].month==1||a[i].month==3||a[i].month==5||a[i].month==7||a[i].month==8||a[i].month==10||a[i].month==12)
				&&(a[i].day>31||a[i].day<=0))
			a[i].year=0;
		else if((a[i].month==4||a[i].month==6||a[i].month==9||a[i].month==11)
				&&(a[i].day>30||a[i].day<=0))
			a[i].year=0;
	}
}
int main()
{
	scanf("%c%c/%c%c/%c%c",&a1,&a2,&b1,&b2,&c1,&c2);
	scan();
	check();
	for(int i=2;i<=6;i++){
		for(int j=i;j>=2;j--)
		{
			if(a[j].year<a[j-1].year)
				swap(j,j-1);
			else if(a[j].year==a[j-1].year)
			{
				if(a[j].month<a[j-1].month)
					swap(j,j-1);
				else if(a[j].month==a[j-1].month)
				{
					if(a[j].day<a[j-1].day)
						swap(j,j-1);
				}
			}
		}
	}
	for(int i=1;i<=6;i++)
	{
		if(a[i].year!=0){
		printf("%d-",a[i].year);
		if(a[i].month/10==0)
			printf("0%d-",a[i].month);
		else
			printf("%d",a[i].month);
		if(a[i].day/10==0)
			printf("0%d\n",a[i].day);
		else
			printf("%d\n",a[i].day);
		}
	}
	return 0;
}

11.第几天

题目：

2000年的1月1日，是那一年的第1天。
那么，2000年的5月4日，是那一年的第几天？

输入与输出：

输入：
无
输出：
一个整数（答案是125）

代码：

//用数组列出每个月的天数，在累加；
#include<stdio.h>
int a[]={0，31,29,31,30,31,30,31,31,30,31,30,31}; 
int main()
{
	int k=0;
	for(int i=1;i<5;i++)
	k+=a[i];
	k+=4;
	printf("%d",k);
	return 0;
}

12.兔子问题

题目：

假设年初在养兔场放养一对小兔子，两个月后小兔长成大兔，大兔每个月生下一对小兔。问第N个月有多少对兔子？（注：这是一道数学题，不是生物题。前提是在此期间，兔子是不会死的）（1<=n<=40）

输入与输出：

输入：
输入一个整数n，表示多少个月
输出：
输出一个整数m，表示有多少对兔子

样例输入：
5
样例输出：
5

代码：

//递推
//和上面的递归如出一辙
#include<stdio.h>
#include<string.h>
int n;
int f[100];
int main()
{
	scanf("%d",&n);
	f[1]=1;
	f[2]=1;
	for(int i=3;i<=n;i++)
	{
		f[i]=f[i-2]+f[i-1];
	}
	printf("%d",f[n]);
	return 0;
}

14.乘积尾零

题目：

如下的10行数据，每行有10个整数，请你求出它们的乘积的末尾有多少个零？

输入与输出：

输入
无
输出
一个整数（答案是31）

代码：

//有多少个0，是由多少个2*5来决定的
//所以分解每个数，看有多少个2和5
//每个2*5都会有一个0，所以取出能组合多少个2*5即可
#include<stdio.h>
#include<string.h>
int a[110],b=0,c=0;
void check1(int n)
{
	while(n%2==0)
	{
		b++;
		n=n/2;
	}
}
void check2(int n)
{
	while(n%5==0)
	{
		c++;
		n=n/5;
	}
}
int min(int i,int j)
{
	return i<j?i:j;
}
int main()
{
	for(int i=1;i<=100;i++)
	{
		scanf("%d",&a[i]);
		check1(a[i]);
		check2(a[i]);
	}
	printf("%d",min(b,c));
	return 0;
}

15.测试次数

题目：

x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。

各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。

x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。

如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。

特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。

如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n

为了减少测试次数，从每个厂家抽样3部手机参加测试。

某次测试的塔高为1000层，如果我们总是采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？

请填写这个最多测试次数。

输入与输出：

输入：
无
输出：
一个整数（答案为19）

代码：

//动态规划类问题
//转移方程是考虑摔了之后碎与不碎
#include<stdio.h>
#include<string.h>
int dp[5][1010];
int k=3,h=1000;
int max(int a,int b)
{
	return a>b?a:b;
}
int min(int a,int b)
{
	return a<b?a:b;
}
int main()
{
	memset(dp,0,sizeof(dp));
	for(int i=1;i<=h;i++)
		dp[1][i]=i;
	for(int i=2;i<=k;i++)
	{
		dp[i][1]=1;
		for(int j=1;j<=h;j++)
		{
			dp[i][j]=dp[i-1][j];
			for(int h=1;h<=j;h++)
			dp[i][j]=min(dp[i][j],max(dp[i][j-h],dp[i-1][h-1])+1);
		}
	}
	printf("%d",dp[k][h]);
}

17.取数位

题目：

求1个整数的第k位数字有很多种方法。

以下的方法就是一种。

// 求x用10进制表示时的数位长度 

int len(int x){

if(x<10) return 1;

return len(x/10)+1;

}

// 取x的第k位数字

int f(int x, int k){

if(len(x)-k==0) return x%10;

return _____________________;  //填空
					//答案为f(x/10,k)
					//调用递归调用，解决问题

}

int main()

{

int x = 23574;

printf("%d\n", f(x,3));

return 0;

}

对于题目中的测试数据，应该打印5。
请仔细分析源码，并补充划线部分所缺少的代码。

输入与输出：

填入正确答案（答案为f(x/10,k)）

18.方格分割

题目：

6x6的方格，沿着格子的边线剪开成两部分。

要求这两部分的形状完全相同。

如图：p1.png, p2.png, p3.png 就是可行的分割法。

试计算：

包括这3种分法在内，一共有多少种不同的分割方法。

注意：旋转对称的属于同一种分割法。

请提交该整数，不要填写任何多余的内容或说明文字。

输入与输出：

输入：
无
输出：
一个整数（答案为509）

代码：

//是从中间的线开始分割，到边线就已经分割成对等的两部分
//同时旋转对称属于同一种，所以答案需要除以4
#include<stdio.h>
#include<string.h>
int x,y,t,num=0;
int map[7][7];
int dx[]={1,-1,0,0},dy[]={0,0,1,-1};
void dfs(int x,int y)
{
	if(x==0||y==0||x==6||y==6)
	{
	num++;
	return ;
	}
	for(int i=0;i<4;i++)
	{
		int dx1=x+dx[i];
		int dy1=y+dy[i];
		if(map[dy1][dx1]==0)
		{
			map[dy1][dx1]=1;
			map[6-dy1][6-dx1]=2;
			dfs(dx1,dy1);
			map[dy1][dx1]=0;
			map[6-dy1][6-dx1]=0;
		}
	}
}
int main()
{
	memset(map,0,sizeof(map));
	x=3,y=3,t=1;
	map[y][x]=1;
	map[6-y][6-x]=2;
	dfs(x,y);
	printf("%d",num/4);
	return 0;
}

23.年号字串

题目：

小明用字母 A 对应数字 1，B 对应 2，以此类推，用 Z 对应 26。对于 27
以上的数字，小明用两位或更长位的字符串来对应，例如 AA 对应 27，AB 对
应 28，AZ 对应 52，LQ 对应 329。
请问 2019 对应的字符串是什么？

输入与输出：

输入：
无
输出：
答案为BYQ

代码：

//枚举
//这里省略了26个字母的其他字母
#include<stdio.h>
int a[100],cnt=0;
int main()
{
	int n=2019;
	while(n)
	{
		a[++cnt]=n%26;
		n/=26;
	}
	for(int i=cnt;i>=1;i--)
	{
		switch(a[i])
		{
			case 2:printf("B");break;
			case 25:printf("Y");break;
			case 17:printf("Q");break;	
		}
	}
	return 0;
}

24.数列求值

题目：

给定数列 1, 1, 1, 3, 5, 9, 17, …，从第 4 项开始，每项都是前 3 项的和。求第 20190324 项的最后 4 位数字。

输入与输出：

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个 4 位整数（提示：答案的千位不为 0），在提交答案时只填写这个整数，填写多余的内容将无法得分。

输入：
无
输出：
一个整数（答案为4659）

代码：

//为了避免数字过大造成错误，所以每次只需要取最后四位即可
#include<stdio.h>
#include<string.h> 
int a,b,c,d;
int main()
{
	int a=1,b=1,c=1;
	for(int i=4;i<=20190324;i++)
	{
		d=(a+b+c)%10000;
		a=b;
		b=c;
		c=d;
	}
	printf("%d",d);
	return 0;
}

26.冒泡排序的过程

题目：

给定包含N个元素的数组a[1],a[2],a[3],…,a[N]，利用冒泡排序将其排成升序。

每次从未排序部分的开头开始冒，将最大值冒到最后。

输入与输出：

输入：
2行
第1行包含1个正整数N（1 < N <= 10000），代表数组元素个数
第2行包含N个整数，空格隔开
输出：
N-1行，既依次输出每趟冒泡排序后的数组

样例输入：
3
3 1 2
样例输出：
1 2 3
1 2 3

代码：

//冒泡排序
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int n,a[10010];
void swap(int *a,int *b)
{
	int t;
	t=*a;
	*a=*b;
	*b=t;
}
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		scanf("%d",&a[i]);
		
	for(int i=n;i>1;i--)
	{
		for(int i=1;i<n;i++)
			if(a[i]>a[i+1])
				swap(&a[i],&a[i+1]);
		for(int i=1;i<=n;i++)
			printf("%d ",a[i]);
		printf("\n");
	}
	return 0;
}

27.删除数组中重复的元素

题目：

输入一组按值递增有序的整数放入一维数组中，数组的元素个数是n,其中有相同的元素.

编写程序，把数组中重复的元素删除的剩一个

输入与输出：

输入:
输入数组元素个数n
按递增输入这n个数组元素（递增有序且有重复的）
输出:
输出删除多于元素后的数组元素

样例输入:
6
2 4 4 5 6 7
样例输出:
2 4 5 6 7

代码：

#include<stdio.h>
#include<string.h> 
int n,a[10000],m,k=0;
int main()
{
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		scanf("%d",&m);
		if(m!=a[k-1])
			a[k++]=m;
	}
	for(int i=0;i<k;i++)
		printf("%d ",a[i]);
	return 0;
}

30.求矩阵的加法

题目：

矩阵int a[3][3]，矩阵int b[3][3]。矩阵的数据由用户输入。输出新的矩阵c=a+b. 输出格式：
c00 c01 c02
c10 c11 c12
c20 c21 c22

每个元素占4位。

输入与输出：

输入:
矩阵a
a00 a01 a02
a10 a11 a12
a20 a21 a22
矩阵b
b00 b01 b02
b10 b11 b12
b20 b21 b22
输出:
矩阵c
c00 c01 c02
c10 c11 c12
c20 c21 c22

样例输入:
1 2 3
4 5 6
7 8 9

7 8 9
4 5 6
1 2 3
样例输出:
8 10 12
8 10 12
8 10 12

代码：

//注意这里的输出每个元素占4位--%4d;
#include<stdio.h>
int a[4][4],b[4][4];
int main()
{
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
		scanf("%d",&a[i][j]);
	for(int i=0;i<3;i++)
		for(int j=0;j<3;j++)
		scanf("%d",&b[i][j]);
	for(int i=0;i<3;i++)
	{
		for(int j=0;j<3;j++)
		printf("%4d",a[i][j]+b[i][j]);
		printf("\n");
	}
	return 0;
}

31.迷宫

题目：

一天Extense在森林里探险的时候不小心走入了一个迷宫，迷宫可以看成是由n * n的格点组成，每个格点只有2种状态，.和#，前者表示可以通行后者表示不能通行。同时当Extense处在某个格点时，他只能移动到东南西北(或者说上下左右)四个方向之一的相邻格点上，Extense想要从点A走到点B，问在不走出迷宫的情况下能不能办到。如果起点或者终点有一个不能通行(为#)，则看成无法办到。

输入与输出：

输入：
第1行是测试数据的组数k，后面跟着k组输入。每组测试数据的第1行是一个正整数n (1 <= n <= 100)，表示迷宫的规模是n * n的。接下来是一个n * n的矩阵，矩阵中的元素为.或者#。再接下来一行是4个整数ha, la, hb, lb，描述A处在第ha行, 第la列，B处在第hb行, 第lb列。注意到ha, la, hb, lb全部是从0开始计数的。
输出：
k行，每行输出对应一个输入。能办到则输出“YES”，否则输出“NO”。

样例输入：
2
3
.##
…#
#…
0 0 2 2
5
…
###.#
…#…
###…
…#.
0 0 4 0
样例输出：
YES
NO

代码：

//在进行迷宫移动类的时候有个技巧就是设置方向数组
//int dx[]={1,-1,0,0};int dy[]={0,0,1,-1};
//或者int next[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
//要是要限定上下左右行走的先后顺序，只需要将先走的放在前面即可
#include<stdio.h>
#include<string.h>
int dx[]={1,-1,0,0};
int dy[]={0,0,1,-1};
int n,ha,la,hb,lb,nx,ny;
bool flag;
char map[200][200];
void dfs(int x,int y)
{
	for(int i=0;i<4;i++)
	{
		nx=x+dx[i];
		ny=y+dy[i];
		if(nx>=0&&nx<n&&ny>=0&&ny<n&&map[nx][ny]=='.')
		{
			map[nx][ny]='#';
			if(nx==hb&&ny==lb)
			{
				printf("YES\n");
				flag=true;
				break;
			}
			else
				dfs(nx,ny);
		}
	}
}
int main()
{
	int k;
	scanf("%d",&k);
	for(int i=0;i<k;i++)
	{
		flag=false;
		scanf("%d",&n);
		memset(map,'#',sizeof(map));
		for(int j=0;j<n;j++)
			for(int h=0;h<n;h++)
			{
				scanf(" %c",&map[j][h]);
			}
		scanf("%d%d%d%d",&ha,&la,&hb,&lb);
		if(map[ha][la]=='#'||map[hb][lb]=='#')
		{
			printf("NO\n");
			continue; 
		}
		else
		{
			dfs(ha,la);
		}
		if(!flag)
		printf("NO\n");
	}
	return 0;
}

32.采药

题目：

辰辰是个很有潜能、天资聪颖的孩子，他的梦想是称为世界上最伟大的医师。为此，他想拜附近最有威望的医师为师。医师为了判断他的资质，给他出了一个难题。医师把他带到个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同的草药，采每一株都需要一些时间，每一株也有它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。”

如果你是辰辰，你能完成这个任务吗？

输入与输出：

输入：
输入的第一行有两个整数T（1 <= T <= 1000）和M（1 <= M <= 100），T代表总共能够用来采药的时间，M代表山洞里的草药的数目。接下来的M行每行包括两个在1到100之间（包括1和100）的的整数，分别表示采摘某株草药的时间和这株草药的价值。
输出：
输出只包括一行，这一行只包含一个整数，表示在规定的时间内，可以采到的草药的最大总价值。

样例输入：
70 3
71 100
69 1
1 2
样例输出：
3

代码：

//动态规划--01背包问题
#include<stdio.h>
#include<string.h>
int t,m,w[1010],v[1010],dp[1010];
int max(int a,int b)
{
	return a>b?a:b;
}
int main()
{
	scanf("%d%d",&t,&m);
	for(int i=1;i<=m;i++)
		scanf("%d%d",&w[i],&v[i]);
	memset(dp,0,sizeof(dp));
	for(int i=1;i<=m;i++)
		for(int j=t;j>=w[i];j--)
		dp[j]=max(dp[j],dp[j-w[i]]+v[i]);
	printf("%d",dp[t]);
	return 0;
} 

33.鸡兔同笼

题目：

一个笼子里面关了鸡和兔子（鸡有2只脚，兔子有4只脚，没有例外）。已经知道了笼子里面脚的总数a，问笼子里面至少有多少只动物，至多有多少只动物

输入与输出：

输入：
第1行是测试数据的组数n，后面跟着n行输入。每组测试数据占1行，每行一个正整数a (a < 32768)
输出：
输出包含n行，每行对应一个输入,包含两个正整数，第一个是最少的动物数，第二个是最多的动物数，两个正整数用一个空格分开
如果没有满足要求的答案，则输出两个0。

样例输入：
2
3
20
样例输出：
0 0
5 10

代码：

//考虑到特殊情况奇数个的时候输出0 0
#include<stdio.h>
#include<string.h> 
int n,m,a,b,c;
int main()
{
	scanf("%d",&n);
	while(n--)
	{
		scanf("%d",&m);
		a=m/4;
		b=m%4;
		c=b/2;
		if(b==1||b==3)
			printf("0 0\n");
		else
			printf("%d %d\n",a+c,a*2+c);
	}
	return 0;
}

34.最大公约数

题目：

输入2个正整数，求出他们的最大公约数。

输入与输出：

输入：
输入两个正整数，只有一行，整数之间用一个空格分开
输出：
输出最大公约数，只有一行，包括三个数据，分别为采用十进制，十六进制和八进制表示的最大公约数，输出数据之间用空格隔开

样例输入：
3 9
样例输出：
3 0x3 03

代码：

//第一种	枚举转化+gcd函数
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef long long ll;
ll a,b,c,d[100000],e[100000],n,m;
int cnt1,cnt2;
ll gcd(ll i,ll j)
{
	return j?gcd(j,i%j):i;
}
int main()
{
	scanf("%lld%lld",&a,&b);
	c=gcd(a,b);
	n=m=c;
	cnt1=0;
	while(n){
		d[cnt1++]=n%16;
		n/=16;
	}
	while(m){
		e[cnt2++]=m%8;
		m/=8;
	}
	printf("%d",c);
	printf(" 0x");
	for(int i=cnt1-1;i>=0;i--)
	{
		if(d[i]<10)
			printf("%d",d[i]);
		else if(d[i]==10)
			printf("a");
		else if(d[i]==11)
			printf("b");
		else if(d[i]==12)
			printf("c");
		else if(d[i]==13)
			printf("d");
		else if(d[i]==14)
			printf("e");
		else if(d[i]==15)
			printf("f");
	}
	printf(" 0");
	for(int i=cnt2-1;i>=0;i--)
		printf("%d",e[i]);
	return 0;
}

//第二种 C语言自带的十进制转16进制和十进制转八进制
//+gcd函数
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef long long ll;
ll a,b,c;
ll gcd(ll i,ll j)
{
	return j?gcd(j,i%j):i;
}
int main()
{
	scanf("%lld%lld",&a,&b);
	printf("%d 0x%x 0%o",gcd(a,b),gcd(a,b),gcd(a,b));
	return 0;
}

35.奇偶排序

题目：

输入十个整数，将十个整数按升序排列输出，并且奇数在前，偶数在后。

输入与输出：

输入：
输入十个整数
输出：
按照奇偶排序好的十个整数

样例输入：
10 9 8 7 6 5 4 3 2 1
样例输出：
1 3 5 7 9 2 4 6 8 10

代码：

//奇偶分开，在进行排序
#include<stdio.h>
#include<string.h> 
int n,a[11],b[11],k1=1,k2=1,m1,m2;
void swap(int *a,int *b)
{
	int t;
	t=*a;
	*a=*b;
	*b=t;
}
int main()
{
	for(int i=1;i<=10;i++)
	{
		scanf("%d",&n);
		if(n%2==0)
		{
			a[k1++]=n;
			m1=k1;
			while(a[m1-1]<a[m1-2])
			{
				if(m1-1==1)
				break;
				swap(&a[m1-1],&a[m1-2]);
				m1--;
			}
		}
		else
		{
			b[k2++]=n;
			m2=k2;
			while(b[m2-1]<b[m2-2])
			{
				if(m2-1==1)
				break;
				swap(&b[m2-1],&b[m2-2]);
				m2--;
			}
		}
	} 
	for(int i=k2;i<=k1+k2-2;i++)
		b[i]=a[i-k2+1];
	for(int i=1;i<=10;i++)
		printf("%d ",b[i]);
	return 0;
}

36.判决素数个数

题目：

输入两个整数X和Y，输出两者之间的素数个数（包括X和Y）。

输入与输出：

输入：
两个整数X和Y（1 <= X,Y <= 105）。
输出：
输出一个整数，表示X，Y之间的素数个数（包括X和Y）。

样例输入：
1 100
样例输出：
25

代码：

//欧拉筛
//同时注意和平时的筛选有点区别
#include<stdio.h>
int x,y;
int num=0,isp[100010],pri[100010],min1,max1,cnt=0;
int max(int a,int b)
{
	return a>b?a:b;
}
int min(int a,int b)
{
	return a<b?a:b;
}

int main()
{
	scanf("%d%d",&x,&y);
	min1=min(x,y);
	max1=max(x,y);
	if(min1==1)
		min1=2;
	for(int i=2;i<=100010;i++){
		if(!isp[i])	pri[++cnt]=i;
		for(int j=1;j<=cnt;j++)
		{
			if(i*pri[j]>max1)	break;
			isp[i*pri[j]]=1;
			if(i%pri[j]==0)	break;
		}
	}
	for(int i=min1;i<=max1;i++)
	{
		if(!isp[i])
			num++;
	}
	printf("%d",num);
	return 0;
}

37.C经典——三数排序

题目：

输入三个整数x,y,z，请把这三个数由小到大输出。

输入与输出：

输入：
三个整数
输出：
将三个整数按小到大输出

样例输入：
3，5，2
样例输出：
2 3 5

代码：

#include<stdio.h>
long long x,y,z;
void swap(long long *a,long long *b)
{
	long long t;
	t=*a,*a=*b,*b=t;
	return ;
}
int main()
{
	scanf("%lld,%lld,%lld",&x,&y,&z);
	if(x>y)	swap(&x,&y);
	if(x>z)	swap(&x,&z);
	if(y>z)	swap(&y,&z);
	printf("%lld %lld %lld",x,y,z);
	return 0;
}

39.数组合并（测试）

题目：

已知两个升序的数组，将它们合并生成一个仍然升序的新数组，要求该合并后的数组元素一次到位。

输入与输出：

输入：
两个升序数组
输出：
一个合并后的升序数组

样例输入：
2 4 6 8
1 3 5 7 9
样例输出：
1 2 3 4 5 6 7 8 9

代码：

//输入方面需要考虑
//需要一个字符=='\n'来判断是否输入完毕
#include<stdio.h>
#define MAXN 100000
int a[MAXN],b[MAXN],c[MAXN];
int main()
{
	int k1=0,k2=0,cnt1=0,cnt2=0;
	char ch;
	while(1){
		scanf("%d",&a[k1++]);
		scanf("%c",&ch);
		if(ch=='\n')
		break;
	}
	while(1){
		scanf("%d",&b[k2++]);
		scanf("%c",&ch);
		if(ch=='\n')
		break;
	}
	int i;
	for(i=0;cnt1<k1&&cnt2<k2;i++)
	{
		if(a[cnt1]<=b[cnt2])
		{
			c[i]=a[cnt1];
			cnt1++;
		}
		else
		{
			c[i]=b[cnt2];
			cnt2++;
		}
	}
	while(cnt1<k1) 		c[i++]=a[cnt1],cnt1++;
	while(cnt2<k2)		c[i++]=b[cnt2],cnt2++;
	for(int j=0;j<i;j++)
		printf("%d ",c[j]);
	return 0;
} 

45.新生插队

题目：

陶陶班里新转来一位学生。体育课上体育老师介绍了一下，然后让他进入队伍。以前的队伍按照高低顺序已经排好了。他从后面挨个比较一下，发现比自己高就让他后退一位，找了一会终于找到比自己矮的同学了，这样他就排在了他的后面。陶陶看了这个过程觉得跟自己学的插入排序很相似，就把这个过程用程序表示出来了。（1<=n<=50）< p="">

输入与输出：

输入：
第一行一个整数n，表示人数
第二行n个升序整数，表示有n个人
第三行一个整数m，表示要插入的人
输出：
将n+1个整数按照升序输出

样例输入：
5
1 2 4 5 6
3
样例输出：
1 2 3 4 5 6

代码：

//插入排序
#include<stdio.h>
#include<string.h> 
int n,m;
int a[100];
int swap(int *a,int *b)
{
	int t;
	t=*a;
	*a=*b;
	*b=t;
}
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n+1;i++)
		scanf("%d",&a[i]);
	for(int i=n+1;i>=2;i--)
	{
		for(int j=1;j<i;j++)
		{
			if(a[j+1]<a[j])
			swap(&a[j+1],&a[j]);
		}
	}
	for(int i=1;i<=n+1;i++)
	printf("%d ",a[i]);
	return 0;
}

46.括号匹配

题目：

我们在写程序时，常常因为括号不匹配而出现Bug。

给出一串由左括号"(“和右括号”)"组成的字符串，判断括号是否匹配

输入与输出：

输入：
一行，由左括号"(“和右括号”)“组成的字符串。
输出：
一行，若括号匹配，输出"yes”，若括号不匹配，输出"no"。

样例输入：
#Example 1:
((()()(())))()

#Example 2:
())(()
样例输出：
#Example 1:
yes

#Example 2:
no

代码：

//建立一个数组，模拟栈来进行括号匹配
//最后数组为空就是匹配完成，不为空就是匹配失败
#include<stdio.h>
#define MAXN 100000
int top=0;
char a[MAXN],ch;
int main()
{
	while(1){
		scanf("%c",&ch);
		if(ch=='\n')
		break;
		a[top++]=ch;
		if(ch==')'&&a[top-2]=='(')
			top-=2;
	}
	if(top==0)
		printf("yes");
	else
		printf("no");
	return 0;
}

47.输出1到n之间所有即不能被2整除，也不能被3整除的所有正整数

题目：

从键盘输入一个整数n，在一行上输出1到n之间所有即不能被2整除，也不能被3整除的所有正整数。每个数之间以一个空格隔开。

输入与输出：

输入：
一个整数n
输出：
在一行上输出1到n之间所有即不能被2整除，也不能被3整除的所有正整数。每个数之间以一个空格隔开。

样例输入：
10
样例输出：
1 5 7

代码：

#include<stdio.h>
int n;
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		if(i%2!=0&&i%3!=0)
			printf("%d ",i);
	}
	return 0;
}

50.斐波那契数列

题目：

构造斐波那契数列，输入是x,y和n。
x和y分别是第一个数和第二个数，n是需要构造的斐波那契数列的长度
输出构造出来的斐波那契数列，以空格分隔

输入与输出：

输入：
输入的x, y, n
输出：
输出构造出来的斐波那契数列，以空格分隔

样例输入：
1 2 5
样例输出：
1 2 3 5 8

代码：

#include<stdio.h>
int x,y,n,a[10000];
int main()
{
	scanf("%d%d%d",&x,&y,&n);
	a[1]=x;
	a[2]=y;
	printf("%d %d",a[1],a[2]);
	for(int i=3;i<=n;i++)
	{
		a[i]=a[i-1]+a[i-2];
		printf(" %d",a[i]);
	}
	return 0;
}

…待做中