OJ题作业10分析.docx
《OJ题作业10分析.docx》由会员分享，可在线阅读，更多相关《OJ题作业10分析.docx（35页珍藏版）》请在冰豆网上搜索。
OJ题作业10分析
作业（10）
1249ProblemA:
SequenceProblem（IV）:
FunctionPractice（AppendCode）
TimeLimit:
1Sec MemoryLimit:
4MB
Submit:
3398 Solved:
1710
[Submit][Status][WebBoard]
Description
整数序列是一串按特定顺序排列的整数，整数序列的长度是序列中整数的个数，不可定义长度为负数的整数序列。
两整数序列A、B的和定义为一个新的整数序列C，序列C的长度是A、B两者中较长的一个，序列C的每个位置上的整数都是A、B对应位置之和。
若序列A、B不等长，不妨假设A比B整数多，那么序列C中多出B的那部分整数视作A的对应位置上的整数与0相加。
你的任务是计算符合某些要求的整数序列的和，这些序列中的整数都是小于1000的非负整数。
-----------------------------------------------------------------------------
编写以下函数，使append.c中的main（）函数能正确运行：
原型：
intmax（inta,intb）;
功能：
返回a和b中较大的一个int值。
原型：
intinit_seq（intseq[],intsize）;
功能：
把int数组seq[]中的前size个元素初始化为0。
原型：
intget_seq（intseq[]）;
功能：
按输入格式的要求，读取size个元素存放在seq[]，返回读到的元素个数。
原型：
intput_seq（intseq[],intsize）;
功能：
按输出格式的要求，把seq[]中的前size个元素输出。
原型：
intadd_seq（intsum_seq[],intadd_seq[],intsize）;
功能：
把sum_seq[]和add_seq[]中的前size个元素相加，结果存储sum_seq[]中。
Input
输入的第一行为一个整数M（M>0），后面有M行输入。
每行第一个整数为N（N<=1000），后接一个长度为N的整数序列。
Output
对输入的整数序列两两相加：
第1行和第2行相加、第2行和第3行相加……按顺序输出结果：
每行输出一个整数序列，每两个整数之间用一个空格分隔。
若最后序列不足两个，则视作补一个长度为0的整数序列相加。
值得注意的是一个长度为0的整数序列也应该有输出，即使没有整数输出，也应该占有一行，因为“每行输出一个整数序列”。
SampleInput
3
3123
51015203050
4100200300400
SampleOutput
1117233050
11021532043050
100200300400
HINT
append.c中的main（）函数简述：
1.定义两个数组odd_seq[]和even_seq[]，分别存储奇数行输入的序列和偶数行输入序列，odd_size和even_size是输入的序列元素个数。
2.输入总行数m；
3.初始化odd_seq[]的全部元素，输入第一行序列，存入odd_seq[]，元素个数存入odd_size；
4.从第2行至第m行重复以下步骤：
4.1要输入的是偶数行：
even_seq[]全体清0，读even_seq[]，把even_seq[]加到odd_seq[]上，输出odd_seq[]；
4.2要输入的是奇数行时与偶数行操作的变量相反，步骤一致；
5.输出最后一行。
AppendCode
append.c,
#include
#defineMAX_SIZE10000
intmax（inta,intb）
{
if（a elsereturna;
}
intinit_seq（intseq[],intsize）
{
inti;
for（i=0;i seq[i]=0;
}
intget_seq（intseq[]）
{
intcnt=0,shit;
scanf（"%d",&shit）;
while（cnt scanf（"%d",&seq[cnt++]）;
returnshit;
}
intput_seq（intseq[],intsize）
{
inti;
for（i=0;i {
printf（"%d",seq[i]）;
if（i!
=size-1）
putchar（''）;
elseputchar（'\n'）;
}
if（size==0）
putchar（'\n'）;
}
intadd_seq（intsum_seq[],intadd_seq[],intsize）
{
inti;
for（i=0;i sum_seq[i]+=add_seq[i];
}
intmain（）
{
int odd_seq[MAX_SIZE], odd_size;
inteven_seq[MAX_SIZE],even_size;
intm,i,put_size;
scanf（"%d",&m）;
init_seq（odd_seq,MAX_SIZE）;
odd_size=get_seq（odd_seq）;
for（i=2;i<=m;i++）
{
if（i%2==0）
{
init_seq（even_seq,MAX_SIZE）;
even_size=get_seq（even_seq）;
put_size=max（odd_size,even_size）;
add_seq（odd_seq,even_seq,put_size）;
put_seq（odd_seq,put_size）;
}
else
{
init_seq（odd_seq,MAX_SIZE）;
odd_size=get_seq（odd_seq）;
put_size=max（odd_size,even_size）;
add_seq（even_seq,odd_seq,put_size）;
put_seq（even_seq,put_size）;
}
}
if（m%2==0）
put_seq（even_seq,even_size）;
else
put_seq（odd_seq,odd_size）;
return0;
}
1053ProblemB:
MatrixProblem:
ArrayPractice
TimeLimit:
1Sec MemoryLimit:
4MB
Submit:
7795 Solved:
2678
[Submit][Status][WebBoard]
Description
求一个m×n阶矩阵A的转置矩阵AT。
矩阵A的每个元素都在int类型的范围之内。
Input
输入的第一行为一个整数M（M>0），后面有M组输入数据。
每组数据以两个正整数m和n开始，满足0Output
输出为多组，每组输出A的转置矩阵AT。
矩阵的输出为：
每行两个元素之间用一个空格分开，每行最后一个元素之后为一个换行，在下一行开始输出矩阵的下一行。
每两组输出之间用一个空行分隔开。
SampleInput
1
33
123
456
789
SampleOutput
147
258
369
HINT
二维数组存储矩阵。
#include
#include
intmain（）
{
intarr1[102][102],num,n,m,k,i,j;
scanf（"%d",&num）;
for（k=0;k {
scanf（"%d%d",&n,&m）;
for（i=0;i for（j=0;j scanf（"%d",&arr1[j][i]）;
for（i=0;i {
for（j=0;j printf（"%d",arr1[i][j]）;
printf（"%d",arr1[i][j]）;
printf（"\n"）;
}
printf（"\n"）;
}
return0;
}
1054ProblemC:
MatrixProblem（II）:
ArrayPractice
TimeLimit:
1Sec MemoryLimit:
4MB
Submit:
5651 Solved:
2246
[Submit][Status][WebBoard]
Description
求两个矩阵A、B的和。
根据矩阵加法的定义，只有同阶的矩阵才能相加。
可以确保所有运算结果都在int类型的范围之内。
Input
输入数据为多个矩阵，每个矩阵以两个正整数m和n开始，满足0当输入的m和n均为0时，表示输入数据结束
Output
对输入的矩阵两两相加：
第1个和第2个相加、第3个和第4个相加……按顺序输出矩阵相加的结果：
每行两个元素之间用一个空格分开，每行最后一个元素之后为一个换行，在下一行开始输出矩阵的下一行。
若输入的矩阵不为偶数个，最后剩余的矩阵不产生任何输出。
不满足矩阵加法定义的数据输出“Notsatisfiedthedefinitionofmatrixaddition!
”
每两组输出之间用一个空行分隔开。
SampleInput
33
123
456
789
33
987
654
321
33
111
111
111
22
22
22
11
0
00
SampleOutput
101010
101010
101010
Notsatisfiedthedefinitionofmatrixaddition!
HINT
矩阵的加法就是对应位置上的元素相加。
#include
#include
#include
intmain（）
{
intarr1[105][105],arr2[105][105];
intx,y;
while（scanf（"%d%d",&x,&y）!
=EOF&&x!
=0&&y!
=0）
{
inti,j,m,n;
for（i=0;i for（j=0;j scanf（"%d",&arr1[i][j]）;
scanf（"%d%d",&m,&n）;
for（i=0;i for（j=0;j scanf（"%d",&arr2[i][j]）;
if（m==0&&n==0）
break;
elseif（m==x&&n==y）
{
for（i=0;i {
for（j=0;j {
if（!
j）printf（"%d",arr1[i][j]+arr2[i][j]）;
elseprintf（"%d",arr1[i][j]+arr2[i][j]）;
}
printf（"\n"）;
}
printf（"\n"）;
}
elseprintf（"Notsatisfiedthedefinitionofmatrixaddition!
\n\n"）;
}
}
1055ProblemD:
MatrixProblem（III）:
ArrayPractice
TimeLimit:
1Sec MemoryLimit:
4MB
Submit:
5100 Solved:
1617
[Submit][Status][WebBoard]
Description
求两个矩阵A、B的乘积C=AB。
根据矩阵乘法的定义，只有A的列数和B的行数相同才能相乘。
可以确保所有运算结果都在int类型的范围之内。
Input
输入数据为多个矩阵（最少2个），每个矩阵以两个正整数m和n开始，满足0当输入的m和n均为0时，表示输入数据结束。
Output
对输入的矩阵两两相乘：
第1个和第2个相乘、第1个和第2个相乘的结果和第3个相乘……按顺序输出矩阵相乘的结果：
每行两个元素之间用一个空格分开，每行最后一个元素之后为一个换行，在下一行开始输出矩阵的下一行。
若前k个矩阵相乘的结果和第k+1个矩阵无法相乘（即不满足矩阵乘法定义），则输出“Notsatisfiedthedefinitionofmatrixmultiplication!
”。
然后用第k+1个矩阵去和第k+2个矩阵相乘。
最后一个矩阵只做乘数。
每两组输出之间用一个空行分隔开。
SampleInput
23
111
111
33
123
456
789
31
0
0
0
00
SampleOutput
121518
121518
0
0
HINT
矩阵的乘法就是一行乘以一列加起来做一个元素。
#include
#include
intmain（）
{
inti,j,k,l=1,m,n,x,y,a[101][101],b[101][101],c[101][101];
while（scanf（"%d%d",&m,&n）!
=EOF）
{
if（m==0&&n==0）break;
elseif（l%2==1）
{
x=m;
y=n;
for（i=0;i for（j=0;j scanf（"%d",&a[i][j]）;
}
elseif（l%2==0）
{
for（i=0;i for（j=0;j scanf（"%d",&b[i][j]）;
if（y==m）
{
//memset（c,0,sizeof（c））;
for（i=0;i for（j=0;j {
c[i][j]=0;
for（k=0;k c[i][j]+=a[i][k]*b[k][j];
}
for（i=0;i {
for（j=0;j {
if（j==0）printf（"%d",c[i][j]）;
elseprintf（"%d",c[i][j]）;
a[i][j]=c[i][j];
c[i][j]=0;
//memset（c,0,sizeof（c））;
}printf（"\n"）;
}printf（"\n"）;
y=n;
l++;
}
else
{
printf（"Notsatisfiedthedefinitionofmatrixmultiplication!
\n"）;
printf（"\n"）;
for（i=0;i for（j=0;j {
a[i][j]=b[i][j];
b[i][j]=0;
}
//memset（b,0,sizeof（b））;
l++;
x=m;
y=n;
}
}l++;
}
}
1298ProblemE:
递归的辗转相除法
TimeLimit:
1Sec MemoryLimit:
128MB
Submit:
3219 Solved:
1821
[Submit][Status][WebBoard]
Description
辗转相除法，也称欧几里得算法，是求最大公约数的算法。
辗转相除法首次出现于欧几里得的《几何原本》（第VII卷，命题i和ii）中，而在中国则可以追溯至东汉出现的《九章算术》。
两个整数的最大公约数（亦称公约数）是能够同时整除它们的最大的正整数。
辗转相除法基于如下原理：
两个整数的最大公约数等于其中较小的数和两数的差的最大公约数。
根据这个原理，不难得出用辗转相除法求最大公约数的递归定义：
下面，给出两个正整数A和B，求他们的最大公约数（gcd（A,B））和最小公倍数（lcm（A,B））。
-----------------------------------------------------------------------------
InvalidWord（禁用单词）错误：
在解决这个题目时，某些关键词是不允许被使用的。
如果提交的程序中包含了下列的关键词之一，就会产生这个错误。
被禁用的关键字：
循环语句for、while，甚至包括分支语句的switch、case、goto、break。
被禁用的头文件：
math.h、stdlib.h。
Input
输入为两个整数A和B，满足0Output
输出两数，分别为gcd（A,B）和lcm（A,B），用一个空格分隔。
SampleInput
2436
SampleOutput
1272
#include
intgcd（inta,intb）
{
intmin,x;
if（a==b）
returnb;
else
{
if（a {
min=a;
x=b-a;
}
else if（a>b）
{
min=b;
x=a-b;
}
升级会员 