A-题目描述：煤球数目
有一堆煤球，堆成三角棱锥形。具体：
第一层放1个，
第二层3个（排列成三角形），
第三层6个（排列成三角形），
第四层10个（排列成三角形），
…
如果一共有100层，共有多少个煤球？
请填表示煤球总数目的数字。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字
我的答案：
4421275
我的编程：
#include <iostream>
using namespace std;
int temp = 0,count = 0;
int main()
{
for(int i = 1;i<=100;i++)
{
for(int j = 1;j<=i;j++)
{
temp += j;
}
count += temp;
}
cout<<count;
return 0;
}
正确答案：
171700
我学到的：
以前的太绕了，现在写个简单的
#define _for(i,a,b) for(int i=a;i<b;i++)
#include <iostream>
using namespace std;
int temp = 0,count = 0;
int main()
{
int temp = 0;
int a[101];
a[1] = 1;
_for(i,2,101)
a[i] = a[i-1]+i;
int sum = 0;
_for(i,1,101)
sum+=a[i];
cout<<sum;
return 0;
}
B-题目描述：生日蜡烛
某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。
现在算起来，他一共吹熄了236根蜡烛。
请问，他从多少岁开始过生日party的？
请填写他开始过生日party的年龄数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字
答案：
26
我的思路：
简单的等差数列，暴力带入
我的编程：
#include <iostream>
using namespace std;
int main()
{
for (int i = 1; i < 236; i++)
{
int count = 0;
for (int j = i; j < 236; j++)
{
count += j;
if (count == 236)
{
cout << j;
break;
}
}
}
return 0;
}
但是跑出来是 33 ，答案却是 26
别人的编程：
#include<stdio.h>
int main()
{
int start,end;
for(start = 1 ; start < 236 ; start ++)
{
for( end = start ; end < 236 ; end ++ )
{
int sum = 0;
for(int i = start; i <= end; i ++)
sum += i;
if( sum == 236)
{
printf("start : %d end : %d\n",start,end);
}
}
}
return 0;
}
我学到的：
我真的是太马虎了，求的是开始过生日的年龄，我算的是现在的年龄，应该将输出 j 改成输出 i （i 是开始过生日的年龄， j 是现在的年龄）
C-题目描述：凑算式
这个算式中A ~ I代表1 ~ 9的数字，不同的字母代表不同的数字。
比如：
6+8/3+952/714 就是一种解法，
5+3/1+972/486 是另一种解法。
这个算式一共有多少种解法？
注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字
答案：
29
我的思路：
全排列
别人的编程：
#include <iostream>
#include <algorithm>
using namespace std;
int ans = 0;
int main()
{
double a[9] = {1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0};
do
{
if(a[0]+a[1]/a[2]+(a[3]*100+a[4]*10+a[5])/(a[6]*100+a[7]*10+a[8]) == 10) ans+=1;
}while(next_permutation(a,a+9));
cout<<ans;
return 0;
}
别人的思路：
水题
我学到的：
无
D-题目描述：快速排序
排序在各种场合经常被用到。
快速排序是十分常用的高效率的算法。
其思想是：先选一个“标尺”，
用它把整个队列过一遍筛子，
以保证：其左边的元素都不大于它，其右边的元素都不小于它。
这样，排序问题就被分割为两个子区间。
再分别对子区间排序就可以了。
下面的代码是一种实现，请分析并填写划线部分缺少的代码
#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;
}
注意：只填写缺少的内容，不要书写任何题面已有代码或说明性文字。
这个题目如果接触过快排，了解过快速排序的原理的应该是送分题目，只不过快排单步(就是将一堆数按照某个数作为基准数分成左右两堆)这个实现方式有几种代码表现
答案：
swap(a,p,j)
我学到的：
之前一直在逃避快速排列法（复杂的表达），一直用简单的表达方式写，但终究还是会面临，所以我打算彻底了解快速排列法
这是我刚刚做好的博客：快速排列法（简易版 → 复杂版），也算是对快速排列法的一次复习吧~
E-题目描述：抽签（未）
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) 或 f(a,k+1,m-j,b)
别人的思路：
这个题目是这样的，对于f(int a[ ],int k,int m,char b[ ]).a[ ] 是每个国家的最多指派人数,k表示当前是哪个国家,m表示还需要派送几个人(可以为负数).b表示已经派送的人的字符串
很明显是一个递归搜索题，第一个参数和最后一个参数肯定是不变的a，b；第二个参数的意思是现在该选哪一个国家,然后看到递归最后k==N，所以第二个应该是k+1；第三个参数可以看到b[M-m+j]，所以推测是m-j
我学到的：
深搜题，感觉可以蒙出来，但我想把代码亲自写出来（现在写不出来）
F-题目描述：方格填数
如下的10个格子
填入0~9的数字。要求：连续的两个数字不能相邻。
（左右、上下、对角都算相邻）
一共有多少种可能的填数方案？
请填写表示方案数目的整数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字
答案：
1580
我的思路：
无
别人的编程：
#include <cstdio>
#include <algorithm> 全排列的头文件
#include <cmath>
int a[11]= {11111,0,1,2,3,4,5,6,7,8,9}; 这里为了使下面填1、2、3对应 格子的位置 好分辨
int judge()
{
if(abs(a[1]-a[2])==1||abs(a[1]-a[4])==1||abs(a[1]-a[5])==1||abs(a[1]-a[6])==1)
return 0;
else if(abs(abs(a[2]-a[3])==1||a[2]-a[5])==1||abs(a[2]-a[6])==1||abs(a[2]-a[7])==1)
return 0;
else if(abs(a[3]-a[6])==1||abs(a[3]-a[7])==1)
return 0;
else if(abs(a[4]-a[5])==1||abs(a[4]-a[8])==1||abs(a[4]-a[9])==1)
return 0;
else if(abs(a[5]-a[6])==1||abs(a[5]-a[8])==1||abs(a[5]-a[9])==1||abs(a[5]-a[10])==1)
return 0;
else if(abs(a[6]-a[7])==1||abs(a[6]-a[9])==1||abs(a[6]-a[10])==1)
return 0;
else if(abs(a[7]-a[10])==1)
return 0;
else if(abs(a[8]-a[9])==1)
return 0;
else if(abs(a[9]-a[10])==1)
return 0;
return 1;
}
int main()
{
int sum=0;
do{
if(judge())
sum++;
}while(next_permutation(a+1,a+11));
cout<<sum;
return 0;
}
别人的思路：
还是利用c++的全排列函数，然后写个judge函数来判断一下相邻的数字是不是连续的就可以了，条件写的时候比较麻烦罢了
核心思想：从第一个格子进行判断，若第2、4、5、6个格子有与之相邻的数字则返回零；再从第二个格子进行判断，若第3、5、6、7个格子有与之相邻的数字则返回零；以此递推…若最后都满足则返回 1 ，然后 sum + 1 ，再进行全排列，直到全部判断完成
我学到的：
再写一遍：next_permutation(a ，a + n)是全排列函数，包含于< algorithm >头文件
G-题目描述：剪邮票
如 图1, 有12张连在一起的12生肖的邮票
现在你要从中剪下5张来，要求必须是连着的。
（仅仅连接一个角不算相连）
比如，图2 ，图3 中，粉红色所示部分就是合格的剪取
请你计算，一共有多少种不同的剪取方法
答案：
116
代码：
#include <iostream>
#include <cstring>
using namespace std;
int mp[12]= {1,2,3,4,6,7,8,9,11,12,13,14};
int aa[5],vis[5],sum=0; //aa假设选择的邮票 vis为已走路径
int b[4]= {-1,1,-5,+5};
void dfs(int n) //验证的元素下标
{
for(int i=0; i<4; i++)
{
int t=aa[n]+b[i];
if(t<1||t>14||t==5||t==10) continue;
for(int j=1; j<5; j++)
if(vis[j]==0&&aa[j]==t) //若此元素满足未走过且与假设的相同
{
vis[j]=1; //代表路径已走过 和 元素与假设相同
dfs(j); //验证下一个元素
}
}
}
int main()
{
for(int a=0; a<12; a++)
for(int b=a+1; b<12; b++)
for(int c=b+1; c<12; c++)
for(int d=c+1; d<12; d++)
for(int e=d+1; e<12; e++)
{
aa[0]=mp[a];
aa[1]=mp[b];
aa[2]=mp[c];
aa[3]=mp[d];
aa[4]=mp[e];
memset(vis,0,sizeof(vis));
vis[0]=1;
dfs(0); //从第一个元素开始验证
int flag=1;
for(int i=0; i<5; i++)
if(vis[i]!=1)
{
flag=0;
break;
}
if(flag==0) continue;
else
sum++;
}
cout<<sum<<endl;
return 0;
}
别人的思路：
先找到5个数的组合，然后从第一个数字开始遍历，经过上下>左右操作检测5个数是否都被访问一遍，如果5个数都可以遍历到>则种类+1。
在原图中向上为-4，向下为+4，向左为-1，向右为+1，但是遇到>3 4 5 7 8这种4+1=5但是这种情况不符合，所以重构一下原图：
我学到的：
将所有情况枚举出来（不超过125），再用 dfs 对枚举的情况进行判断，若符合则算一种情况，若不符则进行循环，这里的判断指的是将枚举的数组的第一个元素进行深搜，直到出现与枚举的数组一样的4个元素再返回（用路径记录每个元素是否相同）
H-题目描述：四平方和定理
四平方和定理，又称为拉格朗日定理：
每个正整数都可以表示为至多4个正整数的平方和。
如果把0包括进去，就正好可以表示为4个数的平方和。
比如：
5 = 02 + 02 + 12 + 22
7 = 12 + 12 + 12 + 22
对于一个给定的正整数，可能存在多种平方和的表示法
要求你对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 >， 不能通过工程设置而省略常用头文件
提交时，注意选择所期望的编译器类型
我的思路：
虽然乍一看想到暴力枚举，但是正常枚举肯定会超时，所以得想一些减少判断的方法
我的编程：
#include <iostream>
#include <cmath>
using namespace std;
int main()
{
long int N;
cin>>N;
cout<<endl;
for(long i = 0;i<=sqrt(N);i++)
{
for(long j = i;j<=sqrt(N);j++)
{
for(long n = j;n<=sqrt(N);n++)
{
for(long m = n;m<=sqrt(N);m++)
{
if(i*i + j*j + n*n + m*m == N)
{
cout<<i<<" "<<j<<" "<<n<<" "<<m;
return 0;
}
}
}
}
}
return 0;
}
尽力了，没能想到什么能减少判断的方法
别人的编程：
#include <stdio.h>
#include <math.h>
int mpt[5000010] ={0}; //mpt[i] = 1表示i 能够用两个完全平方数相加而得。
int n;
void init()
{
for(int i = 0 ; i*i <= n ; i ++)
for(int j = 0 ; j*j <=n ; j ++)
if(i*i+j*j <= n) mpt[i*i+j*j] = 1;
}
int main()
{
scanf("%d",&n);
init();
for(int i = 0 ; i * i <= n ; i ++)
{
for(int j = 0 ; j * j <= n ; j ++){
if(mpt[n - i*i - j*j] == 0) continue; //如果剩下的差用两个完全平方数不能组合出来就不继续
for(int k = 0 ; k * k <= n ; k ++)
{
int temp = n - i*i - j*j - k*k;
double l = sqrt((double) temp);
if(l == (int)l )
{
printf("%d %d %d %d\n",i,j,k,(int)l);
return 0;
}
}
}
}
}
别人的思路；
O(n) 的方法。这个方法是我在比赛的时候用的。先把两个平方数能相加的到的数字球出来然后记录。这样我们第三层循环就可以先判断再循环了
核心思想：这个代码采用了分类讨论的思想，先判断能够用两个平方数相加而得数字，这样就能将原本要执行的四层 for 循环变成先执行两层 for 循环，再判断剩下的两个数字能否用平方数相加而得，若不能则回到第二层 for 循环进行；若能，再继续判断…
而继续判断又可以更简略，只执行第三层， 第四层不用 for 循环，用总数减去前三个平方的和，所得的数字，若开方出来是整数则直接得第四层的答案；若不是则重新返回第三层继续执行…
我学到的：
真的太强了，这数学思维太恐怖了，还是多多刷题多多遇见吧
I-题目描述：交换瓶子
有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 ， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型
代码：
#include <iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
int N,temp,min;
int sum=0;
cin>>N;
vector<int> initState(N+1,0);
for(int i=0;i<N;i++)
cin>>initState[i];
for(int i=0;i<N;i++)
{
min = 10000;
for(int j=i;j<N;j++)
if(min>initState[j])
{
min=initState[j];
temp=j;
}
if(temp!=i)
{
swap(initState[i],initState[temp]);
sum++;
}
}
cout<<sum;
return 0;
}
别人的思路：
其实就是让你排序，只不过要算出需要多少个排序步骤，使用双重for循环，依次找出最小的数放在前面，即可
J-题目描述：最大比例（未）
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 >， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型
代码：
#include<iostream>
#include<algorithm>
#define ll long long
using namespace std;
ll gcd(ll a,ll b)
{
return b==0?a:gcd(b,a%b);
}
bool s(long long a,long long b)
{
return a>b;
}
int main()
{
int n;
cin>>n;
long long a[n],b[n],c[n],x,y;
int j=0;
for(int i=0;i<n;i++)cin>>a[i];
sort(a,a+n,s);
for(int i=0;i<n-1;i++)
{
if(a[i]==a[i+1])continue;
long long f=gcd(a[i],a[i+1]);
b[j]=a[i]/f; //化简得到分母
c[j]=a[i+1]/f; //约分得分子
j++;
}
x=gcd(b[0],b[1]);
for(int i=1;i<j;i++)
x=gcd(b[i],x);
y=gcd(c[0],c[1]);
for(int i=1;i<j;i++)
y=gcd(c[i],y);
sort(b,b+j,s); //从大到小
for(int i=j-1;i>=0;i--)
{
if(b[i]!=x) //不等于最大公约数的最小值除以最大公约数
{
x=b[i]/x;
break;
}
}
sort(c,c+j,s);
for(int i=j-1;i>=0;i--)
{
if(c[i]!=y)
{
y=c[i]/y;
break;
}
}
ll z=gcd(x,y);
x=x/z;
y=y/z;
cout<<x<<"/"<<y<<endl;
return 0;
}
我学到的：
代码很简单，就是不知道为什么这么做
unique 函数的作用
int num[10]={1,1,2,2,2,3,4,5,5,5};
int ans=unique(num,num+10)-num; //5
这时，返回的 ans 是5，而 num 中前 5 项就是1,2,3,4,5，一般使用前需要对容器进行排序，这样才能实现对整个数组去重，unique 实际是一个伪去除，它会把重复的元素添加到容器末尾
159
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
