第一题：
标题：哥德巴赫分解
哥德巴赫猜想认为：不小于4的偶数都可以表示为两个素数的和。
你不需要去证明这个定理，但可以通过计算机对有限数量的偶数进行分解，验证是否可行。
实际上，一般一个偶数会有多种不同的分解方案，我们关心包含较小素数的那个方案。
对于给定数值范围，我们想知道这些包含较小素数方案中最大的素数是多少。
比如，100以内，这个数是19，它由98的分解贡献。
你需要求的是10000以内，这个数是多少？
注意，需要提交的是一个整数，不要填写任何多余的内容（比如，说明性的文字）
答案：173
我的代码：
#include <iostream>
#include <algorithm>
#include <math.h>
using namespace std;
int prime(int h)
{
int ok=0;
for(int i=2;i<h-1;i++)
{
if(h%i!=0)
{
ok=1;
}
else
{
ok=0;
break;
}
}
if(ok==1)
{
return 1;
}
else
{
return 0;
}
}
int cmp(int a,int b)
{
if(a > b)
{
return a;
}
else
{
return b;
}
}
int main()
{
int n;
scanf("%d",&n);
int a[10005],y=0,k;
int z1[10005],s1=0;
for(int i=n;i>=4;i-=2)
{
for(int g=2;g<i/2;g++)
{
k=i-g;
if((prime(k)==1)&&(prime(g)==1))
{
// printf("%d %d\n",g,k);
a[y++] = g;
break;
}
}
}
sort(a,a+y);
printf("%d\n",a[y-1]);
return 0;
}第二题
标题：数字划分
w星球的长老交给小明一个任务：
1,2,3...16 这16个数字分为两组。
要求：
这两组数字的和相同，
并且，两组数字的平方和也相同，
并且，两组数字的立方和也相同。
请你利用计算机的强大搜索能力解决这个问题。
并提交1所在的那个分组的所有数字。
这些数字要从小到大排列，两个数字间用一个空格分开。
即类似：1 4 5 8 ... 这样的答案。
注意，只提交这一组数字，不要填写任何多余的内容。
----------------------------------------
笨笨有话说：
只要一个组的成员确定了，另一个组的成员也就确定了。枚举一个组的成员就可以了。
凭直觉，两个组的成员数目不会差太多吧。
歪歪有话说：
既然求 1 所在的那个组，那只要枚举剩余的成员就可以了。
貌似都是8个成员的可能性很大啊。
答案：1 4 6 7 10 11 13 16
我的代码：
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
int z[1000];
for(int a=2;a<=16;a++)
{
for(int b=2;b<=16;b++)
{
for(int c=2;c<=16;c++)
{
for(int d=2;d<=16;d++)
{
for(int e=2;e<=16;e++)
{
for(int f=2;f<=16;f++)
{
for(int g=2;g<=16;g++)
{
int h=1;
int z1=0;
int sum = 0;
int sum2=0;
int sum3=0;
for(int l=2;l<=16;l++)
{
if((l!=h)&&(l!=a)&&(l!=b)&&(l!=c)&&(l!=d)&&(l!=e)&&(l!=f)&&(l!=g))
{
z[z1++] = l;
}
}
for(int o=0;o<z1;o++)
{
sum3+=z[o];
sum+=z[o]*z[o];
sum2+=z[o]*z[o]*z[o];
}
if(a+b+c+d+e+f+g+h==sum3)
{
if(a*a+b*b+c*c+d*d+e*e+f*f+g*g+1==sum)
{
if(a*a*a+b*b*b+c*c*c+d*d*d+e*e*e+f*f*f+g*g*g+1==sum2)
{
printf("%d %d %d %d %d %d %d %d\n",h,a,b,c,d,e,f,g);
}
}
}
}
}
}
}
}
}
}
return 0;
} 第三题
标题：表达式计算
虽然我们学了许久的程序设计，但对于简单的四则混合运算式，如果让我们完全白手起家地编程来解析，还是有点棘手。
这里，我们简化一下问题，假设只有加法和乘法，并且没有括号来改变优先级。
再假设参加运算的都是正整数。
在这么多的限制条件下，表达式的解析似乎简单了许多。
下面的代码解决了这个问题。请仔细阅读源码，并填写划线部分缺少的代码。
#include <stdio.h>
int f3(const char* s, int begin, int end)
{
int sum = 0;
int i;
for(i=begin; i<end; i++){
if(s[i]==' ') continue;
sum = sum * 10 + (s[i]-'0');
}
return sum;
}
int f2(const char* s, int begin, int end)
{
int p = begin;
int pro = 1;
while(1){
int p0 = p;
while(p!=end && s[p]!='*') p++;
pro *= _____________f3(s,p0,p)__________________; //填空
if(p==end) break;
p++;
}
printf("f2: pro=%d\n", pro);
return pro;
}
int f(const char* s)
{
int p = 0;
int sum = 0;
while(1){
int p0 = p;
while(s[p]!=0 && s[p]!='+') p++;
sum += f2(s,p0,p);
if(s[p]==0) break;
p++;
}
return sum;
}
int main()
{
int x = f("12+18+5*4*3+10");
printf("%d\n", x);
return 0;
}
注意：只填写划线处缺少的内容，不要填写已有的代码或符号，也不要填写任何解释说明文字等。
第四题
标题： 小数第n位
我们知道，整数做除法时，有时得到有限小数，有时得到无限循环小数。
如果我们把有限小数的末尾加上无限多个0，它们就有了统一的形式。
本题的任务是：在上面的约定下，求整数除法小数点后的第n位开始的3位数。
输入：
一行三个整数：a b n，用空格分开。a是被除数，b是除数，n是所求的小数后位置（0<a,b,n<1000000000）
输出：
一行3位数字，表示：a除以b，小数后第n位开始的3位数字。
比如：
输入：
1 8 1
程序应该输出：
125
再比如：
输入：
1 8 3
程序应该输出：
500
再比如：
输入：
282866 999000 6
程序应该输出：
914
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。
----------------------------------------
笨笨有话说：
这个除法小学就会算啊，模拟手算除法的过程就可以了吧。
只是数有点大啊....
管它呢，能算多远算多远....
歪歪有话说：
如果我能确定循环节从哪里开始到哪里结束，再大的数不过就是与它取模的余数等价啊
我的代码：
#include <iostream>
#include <algorithm>
#include <string.h>
using namespace std;
int vis[10];
int main()
{
int a,b,n;
memset(vis,0,sizeof(vis));
scanf("%d %d %d",&a,&b,&n);
int p[1000],q,y=1;
int h[1000];
int h1=0;
p[0]=a/b;
q=a%b;
int ans=0;
int pos = 0;
int ok1=0;
while(q!=0)
{
p[y++]=q*10/b;
q=q*10%b;
if(vis[q]==0)
{
ans++;
h[++h1]=q;
vis[q]=h1;
}
else
{
ok1=1;
break;
}
}
if(ok1==0)
{
printf("%d %d %d\n",p[n],p[n+1],p[n+2]);
}
else
{
// printf("%d %d %d\n",p[n%(ans-1)],p[n%ans],p[n%(ans+1)]);
if(n%ans==0)
{
printf("%d ",p[ans]);
}
else
{
printf("%d ",p[n%ans]);
}
n++;
if(n%ans==0)
{
printf("%d ",p[ans]);
}
else
{
printf("%d ",p[n%ans]);
}
n++;
if(n%ans==0)
{
printf("%d\n",p[ans]);
}
else
{
printf("%d\n",p[n%ans]);
}
}
return 0;
} 第五题
标题：分考场
n个人参加某项特殊考试。
为了公平，要求任何两个认识的人不能分在同一个考场。
求最少需要分几个考场才能满足条件。
输入格式：
第一行，一个整数n(1<n<100)，表示参加考试的人数。
第二行，一个整数m，表示接下来有m行数据
以下m行每行的格式为：两个整数a，b，用空格分开 (1<=a,b<=n) 表示第a个人与第b个人认识（编号从1开始）。
输出格式：
一行一个整数，表示最少分几个考场。
例如：
输入：
5
8
1 2
1 3
1 4
2 3
2 4
2 5
3 4
4 5
程序应该输出：
4
再比如：
输入：
5
10
1 2
1 3
1 4
1 5
2 3
2 4
2 5
3 4
3 5
4 5
则程序应该输出：
5
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。
我的代码
#include <iostream>
#include <algorithm>
#include <vector>
#include <string.h>
int vis[100][100];
using namespace std;
vector<int> room[100];
int n,m;
int top;
int CHU()
{
memset(vis,0,sizeof(vis));
for(int i=0;i<n;i++)
{
room[i].clear();
}
top = 0;
}
int sol(int h)
{
int a,b;
for(int i=0;i<h;i++)
{
scanf("%d %d",&a,&b);
vis[a][b] = 1;
vis[b][a] = 1;
}
}
int judge(int i,int j)
{
int a = i;
int si = room[j].size();
for(int p=0;p<si;p++)
{
int b = room[j][p];
if(vis[a][b]==1)
{
return 0;
}
}
return 1;
}
int jie(int n,int top)
{
for(int i=0;i<n;i++)
{
int ok = 0;
for(int j=0;j<top;j++)
{
if(judge(i,j)==1)
{
room[j].push_back(i);
ok=1;
break;
}
}
if(ok==0)
{
room[top].push_back(i);
top++;
}
}
return top;
}
int main()
{
CHU();
scanf("%d %d",&n,&m);
sol(m);
printf("%d\n",jie(n,top));
return 0;
}第六题
标题：合根植物
w星球的一个种植园，被分成 m * n 个小格子（东西方向m行，南北方向n列）。每个格子里种了一株合根植物。
这种植物有个特点，它的根可能会沿着南北或东西方向伸展，从而与另一个格子的植物合成为一体。
如果我们告诉你哪些小格子间出现了连根现象，你能说出这个园中一共有多少株合根植物吗？
输入格式：
第一行，两个整数m，n，用空格分开，表示格子的行数、列数（1<m,n<1000）。
接下来一行，一个整数k，表示下面还有k行数据(0<k<100000)
接下来k行，第行两个整数a，b，表示编号为a的小格子和编号为b的小格子合根了。
格子的编号一行一行，从上到下，从左到右编号。
比如：5 * 4 的小格子，编号：
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
17 18 19 20
样例输入：
5 4
16
2 3
1 5
5 9
4 8
7 8
9 10
10 11
11 12
10 14
12 16
14 18
17 18
15 19
19 20
9 13
13 17
样例输出：
5
其合根情况参考图[p1.png]
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 2000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。
我的代码