第一题
煤球数目
有一堆煤球，堆成三角棱锥形。具体：
第一层放1个，
第二层3个（排列成三角形），
第三层6个（排列成三角形），
第四层10个（排列成三角形），
....
如果一共有100层，共有多少个煤球？
请填表示煤球总数目的数字。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
思路
这个题单纯来说，是很简单，吧图形画出来，找找规律就好了
#include <iostream>
using namespace std;
int main(int argc, const char * argv[]) {
int pre=1;
int plus=2;
long sum=1;
for (int k = 2; k <=100 ; ++k) {
pre=pre+plus;
sum+=pre;
plus++;
}
cout<<sum<<endl;
return 0;
}
第二题
生日蜡烛
某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。
现在算起来，他一共吹熄了236根蜡烛。
请问，他从多少岁开始过生日party的？
请填写他开始过生日party的年龄数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
思路
直接暴力枚举
#include<stdio.h>
int main()
{
int start,end;
for(i = 1 ; i < 236 ; i ++)
{
for( n = i ;n < 236 ;n ++ )
{
int sum = 0;
for(int j= i; j <= n; j ++)
sum += j;
if( sum == 236)
{
printf("start : %d end : %d\n",i,n);
}
}
}
return 0;
}
第三题
凑算式
B DEF
A + — + -——— = 10
C GHI
（如果显示有问题，可以参见【图1.jpg】）
这个算式中A~I代表1~9的数字，不同的字母代表不同的数字。
比如：
6+8/3+952/714 就是一种解法，
5+3/1+972/486 是另一种解法。
这个算式一共有多少种解法？
注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字。
思路
直接暴力枚举就是了：
#include <iostream>
#include <cmath>
using namespace std;
int a[]={1,2,3,4,5,6,7,8,9};
int ans;
bool check(){
int x = a[3] * 100 + a[4] * 10 + a[5];
int y = a[6] * 100 + a[7] * 10 + a[8];
if((a[1] * y + a[2] * x) % (y * a[2])==0 && a[0] + (a[1] * y + a[2] * x) / (y * a[2]) == 10)
return true;
return false;
}
/*递归回溯生成全排列，适用于无重复元素的情况
* 考虑第k位，前面已经排定*/
void f(int k) {
if(k==9){//一种排列已经生产
if(check())
ans++;
}
// 从k往后的每个数字都可以放在k位
for (int i = k; i < 9; ++i) {
{int t=a[i];a[i]=a[k];a[k]=t;}
f(k+1);//递归
{int t=a[i];a[i]=a[k];a[k]=t;}//回溯
}
}
int main(int argc, const char * argv[]) {
f(0);
cout<<ans<<endl;
return 0;
}
第四题
快速排序
排序在各种场合经常被用到。
快速排序是十分常用的高效率的算法。
其思想是：先选一个“标尺”，
用它把整个队列过一遍筛子，
以保证：其左边的元素都不大于它，其右边的元素都不小于它。
这样，排序问题就被分割为两个子区间。
再分别对子区间排序就可以了。
下面的代码是一种实现，请分析并填写划线部分缺少的代码。
#include <stdio.h>
void swap(int a[], int i, int j)
{
int t = a[i];
a[i] = a[j];
a[j] = t;
}
int partition(int a[], int p, int r)
{
int i = p;
int j = r + 1;
int x = a[p];
while(1){
while(i<r && a[++i]<x);
while(a[--j]>x);
if(i>=j) break;
swap(a,i,j);
}
______________________;
return j;
}
void quicksort(int a[], int p, int r)
{
if(p<r){
int q = partition(a,p,r);
quicksort(a,p,q-1);
quicksort(a,q+1,r);
}
}
int main()
{
int i;
int a[] = {5,13,6,24,2,8,19,27,6,12,1,17};
int N = 12;
quicksort(a, 0, N-1);
for(i=0; i<N; i++) printf("%d ", a[i]);
printf("\n");
return 0;
}
注意：只填写缺少的内容，不要书写任何题面已有代码或说明性文字。
思路：这个手动写一下while循环，然后就可以看出哪两个需要交换位置了
答案：swap(a,p,j)
第五题
抽签
X星球要派出一个5人组成的观察团前往W星。
其中：
A国最多可以派出4人。
B国最多可以派出2人。
C国最多可以派出2人。
....
那么最终派往W星的观察团会有多少种国别的不同组合呢？
下面的程序解决了这个问题。
数组a[] 中既是每个国家可以派出的最多的名额。
程序执行结果为：
DEFFF
CEFFF
CDFFF
CDEFF
CCFFF
CCEFF
CCDFF
CCDEF
BEFFF
BDFFF
BDEFF
BCFFF
BCEFF
BCDFF
BCDEF
....
(以下省略，总共101行)
#include <stdio.h>
#define N 6
#define M 5
#define BUF 1024
void f(int a[], int k, int m, char b[])
{
int i,j;
if(k==N){
b[M] = 0;
if(m==0) printf("%s\n",b);
return;
}
for(i=0; i<=a[k]; i++){
for(j=0; j<i; j++) b[M-m+j] = k+'A';
______________________; //填空位置
}
}
int main()
{
int a[N] = {4,2,2,1,1,3};
char b[BUF];
f(a,0,M,b);
return 0;
}
仔细阅读代码，填写划线部分缺少的内容。
注意：不要填写任何已有内容或说明性文字。
思路：这个题吧递归的每个参数的含义看懂，以及那些参数需要变化，以及每次参赛人数看懂就很简单了
答案：f(a,k+1,m-i,b)
第六题
方格填数
如下的10个格子
（如果显示有问题，也可以参看【图1.jpg】）
填入0~9的数字。要求：连续的两个数字不能相邻。
（左右、上下、对角都算相邻）
一共有多少种可能的填数方案？
请填写表示方案数目的整数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
如下的10个格子
+--+--+--+
| | | |
+--+--+--+--+
| | | | |
+--+--+--+--+
| | | |
+--+--+--+
思路：
1.这种题，随机填数字，很容易想到递归，反正就那么多，慢慢排就是了
2.然后关于那个要求，就很简单了，直接吧格子看成一维数组，然后进行编号，然后设置那些和那些不能相邻
3.然后，这个题也就做完了，很简单的一道递归
#include <iostream>
#include <stdlib.h>
using namespace std;
int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int ans;
bool check(){
if(abs(a[0]-a[1])==1||
abs(a[0]-a[3])==1||
abs(a[0]-a[4])==1||
abs(a[0]-a[5])==1||
abs(a[1]-a[2])==1||
abs(a[1]-a[4])==1||
abs(a[1]-a[5])==1||
abs(a[1]-a[6])==1||
abs(a[2]-a[5])==1||
abs(a[2]-a[6])==1||
abs(a[3]-a[4])==1||
abs(a[3]-a[7])==1||
abs(a[3]-a[8])==1||
abs(a[4]-a[5])==1||
abs(a[4]-a[7])==1||
abs(a[4]-a[8])==1||
abs(a[4]-a[9])==1||
abs(a[5]-a[6])==1||
abs(a[5]-a[8])==1||
abs(a[5]-a[9])==1||
abs(a[6]-a[9])==1||
abs(a[7]-a[8])==1||
abs(a[8]-a[9])==1)
return false;
return true;
}
/*考虑第k个位置，一般从0开始*/
void f(int k) {
//出口
if (k == 10) {
bool b = check();
if(b)
ans++;
return;
}
for (int i = k; i < 10; ++i) {
//尝试将位置i与位置k交换，以此确定k位的值
{
int t = a[i];
a[i] = a[k];
a[k] = t;
}
f(k + 1);
// 回溯
{
int t = a[i];
a[i] = a[k];
a[k] = t;
}
}
}
int main(int argc, const char *argv[]) {
f(0);
cout << ans << endl;
return 0;
}
第七题
剪邮票
如【图1.jpg】, 有12张连在一起的12生肖的邮票。
现在你要从中剪下5张来，要求必须是连着的。
（仅仅连接一个角不算相连）
比如，【图2.jpg】，【图3.jpg】中，粉红色所示部分就是合格的剪取。
请你计算，一共有多少种不同的剪取方法。
请填写表示方案数目的整数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
思路
我个人认为这个题和最后一道最大比例最难，其余都还好，所以下面思路看起来很简单，实现还是有点头大
1.看着这种题，其实很容易还是想到暴力破解吧，各种递归深搜、各种回溯
2.好吧，现在开始第一步，还是吧我们12个方格的所有情况都列出来，就是用一维数组+递归+回溯
3.然后因为我们数组里面有重复的元素，因为我们只选5个数嘛，重复的方法很多很多，所以我们加了一个set集合判断
4.然后就是对每一种情况进行集合查重，以及一个检查，是否符合题意
5.去重其实很简单，就是一个查询，这里讲一讲检查
1.检查，首先还是吧我们的数组变为二维的数组，方便后面的递归，可以根据已有的下标转换为二维的哦
2.然后转换为二维数组以后，对每一个数组元素为1的进行一个检查，如果检查出来的连通块刚好是1，那就是符合的，否则不符合
3.然后递归，就很简单了，很单纯的一个递归了，没有回溯，只有最简单的一个判断
以上就是一个思路，其实我认为难，主要如下原因：
1.想不到去重
2.想到去重，搞忘set，因为不怎么学c++
3.然后就是不知道怎么去判断一个连通块的问题
#include <algorithm>
#include <iostream>
#include <set>
using namespace std;
int a[]={0,0,0,0,0,0,0,1,1,1,1,1};//它的每个排列代表着12选5的一个方案
int ans;
void dfs(int g[3][4],int i , int j){
g[i][j]=0;
if(i-1>=0&&g[i-1][j]==1)dfs(g,i-1,j);
if(i+1<=2&&g[i+1][j]==1)dfs(g,i+1,j);
if(j-1>=0&&g[i][j-1]==1)dfs(g,i,j-1);
if(j+1<=3&&g[i][j+1]==1)dfs(g,i,j+1);
}
bool check(){
int g[3][4];
// 将某个排列映射到二维矩阵上
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 4; ++j) {
if(a[i*4+j]==1) g[i][j]=1;
else g[i][j]=0;
}
}
int cnt=0;//连通块的数目
// g上面就有5个格子被标记为1，现在才用dfs做连通性检查，要求只有一个连通块
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 4; ++j) {
if(g[i][j]==1){
dfs(g,i,j);
cnt++;
}
}
}
return cnt==1;
}
set<string> s1;
void a2s(string &s){
for (int i = 0; i < 12; ++i) {
s.insert(s.end(),a[i]+'0');
}
}
bool isExist(){
string a_str;
a2s(a_str);
if(s1.find(a_str)==s1.end()){
s1.insert(a_str);
return false;
} else
return true;
}
void f(int k){
if(k==12){
if(!isExist()&&check()){
ans++;
}
}
for (int i = k; i < 12; ++i) {
{int t=a[i];a[i]=a[k];a[k]=t;}
f(k+1);
{int t=a[i];a[i]=a[k];a[k]=t;}
}
}
int main(int argc, const char *argv[]) {
f(0);
printf("%d",ans);
//string _s;
//a2s(_s);
//cout<<_s<<endl;
return 0;
}
第八题
四平方和
四平方和定理，又称为拉格朗日定理：
每个正整数都可以表示为至多4个正整数的平方和。
如果把0包括进去，就正好可以表示为4个数的平方和。
比如：
5 = 0^2 + 0^2 + 1^2 + 2^2
7 = 1^2 + 1^2 + 1^2 + 2^2
（^符号表示乘方的意思）
对于一个给定的正整数，可能存在多种平方和的表示法。
要求你对4个数排序：
0 <= a <= b <= c <= d
并对所有的可能表示法按 a,b,c,d 为联合主键升序排列，最后输出第一个表示法
程序输入为一个正整数N (N<5000000)
要求输出4个非负整数，按从小到大排序，中间用空格分开
例如，输入：
5
则程序应该输出：
0 0 1 2
再例如，输入：
12
则程序应该输出：
0 2 2 2
再例如，输入：
773535
则程序应该输出：
1 1 267 838
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 3000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。
思路：
1.这个题整体看上去其实不难，就是找四个数，然后平方和等于输入的数
2.也很容易想到解法就是一个暴力循环，就可以解出来了
3.好了，这里如果单纯的四重循环，也确实可以解出来，但是，效率有影响，所以可以考虑换个方法
新思路：
1.可以考虑分成两个双重循环，然后中间再用一个东西去存放这个值，
2.然后，这个循环的大小我们也可以限制一下，N/2，因为你大于N/2以后再平分很容易就大于原数了
3.用map去存放中间的结果
下面给出两种解法
#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
#include <cmath>
using namespace std;
int main()
{
int n;
scanf("%d",&n);
int l=sqrt(n);
int ll,f=0;
for(int i=0; i<=l; i++)
{
if(i*i>=n) break;
for(int j=i; j<=l; j++)
{
if(i*i+j*j>=n) break;
for(int k=j; k<=l; k++)
{
ll=i*i+j*j+k*k;
if(ll>=n) break;
double sum=sqrt(n-ll);
if(sum==(int)sum)
{
printf("%d %d %d %d\n",i,j,k,(int)sum);
f=1;
break;
}
}
if(f) break;
}
if(f) break;
}
return 0;
}
解法二：
import static java.lang.Math.*;
public class _08四平方和 {
static int N;
static Map<Integer,Integer> cache=new HashMap<Integer,Integer>();
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
N = sc.nextInt();
for (int c = 0; c*c <=N/2 ; ++c) {
for (int d = c; c*c+d*d <= N; ++d) {
if(cache.get(c*c+d*d)==null)
cache.put(c*c+d*d,c);
}
}
for (int a = 0; a*a <=N/4 ; ++a) {
for (int b = a; a*a+b*b<=N/2 ; ++b) {
if(cache.get(N-a*a-b*b)!=null){
int c = cache.get(N-a*a-b*b);
int d=(int)sqrt(N-a*a-b*b-c*c);
System.out.printf("%d %d %d %d\n",a,b,c,d);
return;
}
}
}
}
}
第九题
交换瓶子
有N个瓶子，编号 1 ~ N，放在架子上。
比如有5个瓶子：
2 1 3 5 4
要求每次拿起2个瓶子，交换它们的位置。
经过若干次后，使得瓶子的序号为：
1 2 3 4 5
对于这么简单的情况，显然，至少需要交换2次就可以复位。
如果瓶子更多呢？你可以通过编程来解决。
输入格式为两行：
第一行: 一个正整数N（N<10000）, 表示瓶子的数目
第二行：N个正整数，用空格分开，表示瓶子目前的排列情况。
输出数据为一行一个正整数，表示至少交换多少次，才能完成排序。
例如，输入：
5
3 1 2 5 4
程序应该输出：
3
再例如，输入：
5
5 4 3 2 1
程序应该输出：
2
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。
思路：
1.哈哈，这个题，有没有其他正规的思路我就不知道了，我下面讲的是一个取巧的思路
例子：
例如，输入：
5
3 1 2 5 4
程序应该输出：
3
再例如，输入：
5
5 4 3 2 1
程序应该输出：
2
第一种 1 3交换 然后2 3交换 然后4 5交换 都是将对应元素交换到对应的位置上
第二种 1 5交换 2 4交换
所以，就很简单了啊，只需要看这个元素是否在应该的位置上，不是就交换，，是就不交换
#include <iostream>
using namespace std;
int n;
int a[10001];
int ans;
int pos(int x) {
for (int i = 1; i <= n; ++i) {
if (a[i] == x)return i;
}
return -1;
}
void swap(int i, int j) {
int t = a[i];
a[i] = a[j];
a[j] = t;
}
int main(int argc, const char *argv[]) {
// 处理输入
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
//遍历i:1-N
for (int i = 1; i <= n; ++i) {
//如果a[i]=i,已经到位
if (a[i] == i)continue;
//否则先找到i在a中的位置pos(i)和i位交换——swap(a,pos(i),i)
else {
swap(pos(i), i);
ans++;
}
}
printf("%d\n", ans);
return 0;
}
第十题
最大比例
X星球的某个大奖赛设了M级奖励。每个级别的奖金是一个正整数。
并且，相邻的两个级别间的比例是个固定值。
也就是说：所有级别的奖金数构成了一个等比数列。比如：
16,24,36,54
其等比值为：3/2
现在，我们随机调查了一些获奖者的奖金数。
请你据此推算可能的最大的等比值。
输入格式：
第一行为数字N，表示接下的一行包含N个正整数
第二行N个正整数Xi(Xi<1 000 000 000 000)，用空格分开。每个整数表示调查到的某人的奖金数额
要求输出：
一个形如A/B的分数，要求A、B互质。表示可能的最大比例系数
测试数据保证了输入格式正确，并且最大比例是存在的。
例如，输入：
3
1250 200 32
程序应该输出：
25/4
再例如，输入：
4
3125 32 32 200
程序应该输出：
5/2
再例如，输入：
3
549755813888 524288 2
程序应该输出：
4/1
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 3000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。
思路：本题我只给出一个可实现的思路，但没有具体实现相应算法，代码是另一种解法
如下的思路，后半部分仅仅只有思路，没有实现代码，有兴趣可以自己尝试
1.首先这个题，是需要我们找一个公比出来
2.然后这个题，其实一样的可以取巧的，有个相对比较容易的算法
3.首先我们将数组进行一个简单的排序，然后讲重复的数据删除
4.然后，我们只需要计算两个公比就可以了，只需要计算最开始的，以及最后的，（也就是分母分子最大以及分母分子最小）
5.然后我们用已知的例子，很容易看出，这两个公比是呈现一个次方关系，那么接下来的重点就是这个次方
次方的思路如下：
1.首先看最小的公比，分子分母是否包含素数，如果包含素数就可以直接输出，那个就是答案了
2.如果没有包含素数，那么就可以进行如下的方法
1.用最大的分母除以最小的分母，最大的分子除以最小的分子（肯定可以整除，这个不用担心）
2.然后看看除数能不能进行开方运算，如果可以开方可以直接进行开方运算，然后一直循环开方，直到出现素 数未知，就可以输出答案
3.如果不能开方，说明这个次方就是奇数次方，这样，我们就用（最大的数、最小的数、除数），中间选择除 数和最小的数，进行一个比较，用大数去除小数，然后再循环以上的方法
这个次方的仅仅是思路，但是结果肯定是对的
#include <stdio.h>
#include <algorithm>
#include <queue>
using namespace std;
#define LL long long
struct fs
{
LL up,down;
};
int n;
LL arr[110];
fs Fs[110];
bool cmp(LL a,LL b)
{
return a > b;
}
LL Gcd(LL a,LL b)
{
if( b == 0 )return a;
return Gcd(b,a%b);
}
LL Get(LL a, LL b)
{
if( a < b) a ^= b ^= a ^= b;
LL v[30];
queue<LL>team;
if( a == b || a / b == a) return b;
v[0] = a, v[1] = b;
v[2] = a / b;
int top = 3,i,j;
team.push(a/b);
while(team.size())
{
LL now = team.front();
team.pop();
for(i = 0 ; i < top ; i ++)
{
LL temp = (v[i] > now) ? v[i] / now : now / v[i];
bool find = false;
for(j = 0 ; j < top ; j ++)
if( v[j] == temp) find = true;
if(find == true) continue;
team.push(temp);
v[top++] = temp;
}
}
LL ans = v[0];
for(i = 0 ; i < top ; i ++)
if(v[i] != 1)
{
ans = v[i];
break;
}
for(i = 0 ; i < top ; i ++)
if( v[i] < ans && v[i] != 1) ans = v[i];
return ans;
}
int main()
{
int i,j;
scanf("%d",&n);
for(i = 0 ; i < n ; i ++) scanf("%lld",&arr[i]);
sort(arr,arr+n,cmp);
int top = 1;
for(i = 1; i < n ; i ++)
if(arr[i] != arr[i-1]) arr[top++] = arr[i];
n = top;
for(i = 0 ; i < n - 1; i ++)
{
LL gcd = Gcd(arr[i],arr[i+1]);
Fs[i].up = arr[i] / gcd;
Fs[i].down = arr[i+1] / gcd;
}
LL x = Fs[0].up;
for(i = 0 ; i < n - 1 ; i ++)
x = Get(x,Fs[i].up);
LL y = Fs[0].down;
for(i = 0 ; i < n - 1; i ++)
y = Get(y,Fs[i].down);
printf("%lld/%lld\n",x,y);
return 0;
}