计算机科学技术专业技能模拟考核.docx
《计算机科学技术专业技能模拟考核.docx》由会员分享，可在线阅读，更多相关《计算机科学技术专业技能模拟考核.docx（25页珍藏版）》请在冰豆网上搜索。
计算机科学技术专业技能模拟考核
1.最短距离（本题100分）
（dist.cpp/c）
【问题描述】
开车从起始点Ａ到目的地Ｂ的路线有多条。
给你一张描述待选路线的表（n*n的矩阵A），让你找出行车距离最短的路线。
表中表示了任意两个路口的连通情况，以及距离。
矩阵元素a（i,j）=0表示路口i,j不连通，a（i,j）!
=0表示路口i,j的行车距离。
其中起始点Ａ在路口1，目的地Ｂ在路口n。
完成源程序DIST.CPP中Dijkstra函数的编写。
#include"stdio.h"
#definemaxint10000
intn,used[31],map[31][31];
voidini（）
{
inti,j;
scanf（"%d",&n）;
for（i=1;i<=n;i++）
for（j=1;j<=n;j++）
{
scanf（"%d",&map[i][j]）;
if（map[i][j]==0）map[i][j]=maxint;
}
}
voidDijkstra（）{
intdist[100];
inti,j;
//初始
for（i=1;i<=n;i++）
{
dist[i]=map[1][i];
used[i]=0;
}
used[1]=1;
for（i=1;i{
//选择最短
intmind=maxint,k=-1;
for（j=1;j<=n;j++）
{
if（!
used[j]&&dist[j]{
mind=dist[j];
k=j;
}
}
if（k<0）
break;
used[k]=1;
//路径扩展
for（j=1;j<=n;j++）
{
if（!
used[j]&&map[k][j]{
dist[j]=dist[k]+map[k][j];
}
}
}
printf（"%d\n",dist[n]）;
}
intmain（）
{
freopen（"dist.in","r",stdin）;
freopen（"dist.out","w",stdout）;
ini（）;
Dijkstra（）;
return0;
}
【输入】
输入文件dist.in的第一行为一个自然数n（1接着n行，每行n个整数，描述待选路线的表（元素的值小于1000）；
【输出】
输出文件dist.out包括一行，为一个整数，表示起始点Ａ到目的地Ｂ的最短行车的距离。
【输入输出样例1】
dist.in
dist.out
4
0234
2011
3100
4100
3
【输入输出样例2】
dist.in
dist.out
6
013490
102130
320048
410037
8
934304
008740
2.路径回溯（本题100分）
（DictS.cpp）
【问题描述】
已知从起始点Ａ到达各目站点（Ｂ、C、D...）的各最短路径上所有站点的前驱站点，以及至前驱站点的距离。
以一个二维数组pre描述已知信息，第1列是前驱站点的序号（以0、1、2...分别表示站点A、B、C...），第2列是至前驱站点的距离。
试推算和输出从起始点出发到达各其余站点的最短路径和距离。
完成源程序DictS.CPP中Pathway函数的编写。
#include"stdio.h"
intn,pre[26][2];
charstation[26]={'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
voidini（）
{
inti;
scanf（"%d",&n）;
for（i=0;iscanf（"%d%d",&pre[i][0],&pre[i][1]）;
}
voidPathway（）
{
//********************************************************
inti,j,sum=0;
intst[100],top;
for（i=1;i{//从'B'开始
for（j=i,top=sum=0;;）
{//从尾到头（'A'）进栈
st[top++]=pre[j][0];
sum+=pre[j][1];
j=pre[j][0];
if（j==0）
{//到达'A'
break;
}
}
for（j=top-1;j>=0;j--）
{
printf（"%c-",station[st[j]]）;
}
printf（"%c",station[i]）;
printf（"%d\n",sum）;
}
//========================================================
}
intmain（）
{
freopen（"DictS.in","r",stdin）;
freopen（"DictS.out","w",stdout）;
ini（）;
Pathway（）;
fclose（stdin）;
fclose（stdout）;
return0;
}
【输入】
输入文件DictS.in的第1行为1个自然数n（1后续n行，每行2个整数，分别描述站点A、B、C...的前驱站点和至前驱站点的距离。
【输出】
输出文件DictS.out包含n-1行，每行2个部分，前部为最短路径，后部为距离。
格式见输出样例。
【输入输出样例1】
DictS.in
DictS.out
9
00
040
020
410
030
225
310
240
620
A-B40
A-C20
A-E-D40
A-E30
A-C-F45
A-E-D-G50
A-C-H60
A-E-D-G-I70
【输入输出样例2】
DictS.in
DictS.out
5
00
275
0135
033
0123
A-C-B210
A-C135
A-D33
A-E123
3.有限自动机（本题100分）
（dfa.cpp/c）
【问题描述】
设有如下确定的状态转换图，0为起始状态，3，4为终结状态。
编写程序，判断用户输入的符号串，是否被该有限自动机接受。
#include"stdio.h"
#definemax1000
intdfachk（charstr[]）
{//********************************************************
inti,j,f[10][5];
ints=0;
for（i=0;i<10;i++）
{
for（j=0;j<5;j++）
{
f[i][j]=-1;
}
}
//根据表转换:
f[i][j]=k,代表从状态i,输入字符j,（j:
0代表'a',1:
代表'b'），转移到状态k
f[0][0]=0;
f[0][1]=1;
f[1][0]=2;
f[2][0]=1;
f[1][1]=3;
f[3][1]=3;
f[3][0]=4;
f[4][0]=3;
//一遍循环字符串,头到尾
for（i=0;str[i];i++）
{
if（str[i]!
='a'&&str[i]!
='b'）
returni+1;//非'a'非'b'
s=f[s][str[i]-'a'];
if（s<0）
returni+1;//无路可走
}
if（s!
=3&&s!
=4）
returni+1;//非法结束
return0;
//========================================================
}
voidmain（）
{
charins[max]={0};
freopen（"dfa.in","r",stdin）;
freopen（"dfa.out","w",stdout）;
gets（ins）;
printf（"%d",dfachk（ins））;
}
【输入】
输入文件dfa.in为一行字符串（字符个数小于1000）；
【输出】
输出文件dfa.out包括一行，为一个整数，表示输入的符号串是否被该有限自动机接受，若接受，则输出0，否则输出首次出错字符所在的位置（注：
输入串首字符的位置为1）。
学生只要编写函数intdfachk（charstr[]），该函数的参数str为输入串，若输入串str被该有限自动机接受，则函数返回值为0。
若输入串str在第n个字符处首次出错，则函数返回值为n。
【输入输出样例1】
dfa.in
dfa.out
aa
3
【输入输出样例2】
dfa.in
dfa.out
abbaaa
0
【输入输出样例3】
dfa.in
dfa.out
ababaaab
4
【输入输出样例4】
dfa.in
dfa.out
abaacaab
5
【数据规模】
输入的字符串长度L<1000
4.数据库查询（本题100分）
（DB.c）
【问题描述】
Student数据库里面有个Grade表，该表里面存储了每个学生的学号，姓名，maths成绩，english成绩和computer成绩。
现要查询Grade表，显示三门课都及格的学生学号、姓名、maths、english、computer字段，并按照学号升序排列。
完成源程序DB.C中select2函数的编写。
#include
#defineSIZE100
intn;
structGrade_table
{
intno_stu;/*thenumberofstudent*/
charname[20];/*thenameofstudent*/
intmaths;
intenglish;
intcomputer;
};
structGrade_tablegrade[SIZE];
voidini（）
{
inti,j=0;
scanf（"%d",&n）;
for（i=0;i{
scanf（"%d%s%d%d%d",&（grade[i].no_stu）,grade[i].name,&（grade[i].maths）,&（grade[i].english）,&（grade[i].computer））;
}
}
voidselect2（）
{
//********************************************************
intrank[SIZE],tot=0;
inti,j,k;
for（i=0;i{
if（grade[i].maths>=60&&grade[i].english>=60&&grade[i].computer>=60）
{
//存下标
rank[tot++]=i;
}
}
//选择排序，只对下标排序，比较简单
for（i=0;i{
k=i;
for（j=i+1;j{
if（grade[rank[j]].no_stu{//记录最小
k=j;
}
}
if（k!
=i）
{//最小学号的下标k与i交换
Grade_tabletmp=grade[rank[k]];
grade[rank[k]]=grade[rank[i]];
grade[rank[i]]=tmp;
}
}
for（i=0;i{
printf（"%d,%s,%d,%d,%d\n",grade[rank[i]].no_stu,grade[rank[i]].name,grade[rank[i]].maths,
grade[rank[i]].english,grade[rank[i]].computer）;
}
//========================================================
}
intmain（）
{
freopen（"DB.in","r",stdin）;
freopen（"DB.out","w",stdout）;
ini（）;
select2（）;
return0;
}
【输入】
输入文件DB.in的第一行为一个自然数n（1接着n行，每行代表一个学生的记录（学号姓名maths成绩english成绩computer成绩），其中0<=成绩<=100，每个字段之间用空格间隔开。
【输出】
输出文件DB.out包括x行，每行代表一个学生的记录，显示字段为：
学号、姓名、maths成绩、english成绩、computer成绩。
每个字段之间用逗号间隔开
【输入输出样例1】
DB.in
DB.out
4
101Zhangsan564789
102Kate896078
102,Kate,89,60,78
107,Wangwu,68,78,67
104Jay528990
107Wangwu687867
【输入输出样例2】
DB.in
DB.out
10
145Anm448676
123Bob986686
246Bay969593
286Bekt568623
281Eho868475
301Dawy656364
324Deuwu786556
320Dyosn231465
411Eio763181
450Erobt132347
123,Bob,98,66,86
246,Bay,96,95,93
281,Eho,86,84,75
301,Dawy,65,63,64
5.图像平滑线性滤波器（本题100分）
（image.cpp）
【问题描述】
利用加权平均掩模实现数字图像的平滑（图像边缘不予处理）；加权平均掩模如下图。
完成源程序 image.cpp中Smooth_Filter函数的编写。
#include"stdio.h"
#defineMAX_INT300
intn,map[MAX_INT][MAX_INT],out[MAX_INT][MAX_INT];
voidini（）
{inti,j;
for（i=0;ifor（j=0;j{
map[i][j]=0;
out[i][j]=0;
}
scanf（"%d",&n）;
for（i=0;ifor（j=0;jscanf（"%d",&map[i][j]）;
}
voidSmooth_Filter（）{
//********************************************************
inti,j,p,q,sum;
//加权平均掩模
intsrc[3][3]={{1,2,1},{2,4,2},{1,2,1}};
//加权平均例如第1行第1列=（1*0+2*2+1*3+2*2+4*0+2*1+1*3+2*1+1*0）/16
for（i=0;i{
for（j=0;j{
sum=0;
for（p=i;p{
for（q=j;q{
sum+=map[p][q]*src[p-i][q-j];
}
}
sum/=16;
//out[i][j]=sum;
printf（"%d",sum）;//我直接输出sum,也可保存在out[i][j]中最后输出
j==n-3?
printf（"\n"）:
printf（""）;
}
}
//========================================================
}
intmain（）
{freopen（"image.in","r",stdin）;
freopen（"image.out","w",stdout）;
ini（）;
Smooth_Filter（）;
return0;
}
【输入】
输入文件 image.in的第一行为一个自然数n（1=接着n行，每行n个整数，描述n×n像素图像（元素的值介于0～255之间）；
【输出】
输出文件image.out为n-2行，每行n-2个整数，表示滤波后n-2×n-2像素图像。
【输入输出样例1】
image.in
image.out
4
0234
2011
3100
4100
11
10
【输入输出样例2】
image.in
image.out
6
111111
111111
111111
111111
111111
111111
1111
1111
1111
1111
6.模拟进程调度算法（本题100分）
（os.cpp）
【问题描述】
进程调度算法FCFS+SJF模拟。
编写FCFS+SJF算法，输入一组若干个进程的调度信息，输出根据先来先服务和短进程优先算法的调度结果。
（提示：
短进程优先算法仅在进程的到达时间一样时，才启用）。
完成源程序 os.cpp中fcfs_sjf函数的编写。
提醒：
每个输出数据之前输出1个‘\t’。
#include
#include
structJob_type
{
intno;//作业号
inttb;//作业开始时间（分）
inttr;//运行时间（分）
}x;
Job_typejob[36];
intn;
voidload（）
{inti,j;
scanf（"%d",&n）;
for（i=0;i{scanf（"%d",&job[i].no）;
scanf（"%d",&job[i].tb）;
scanf（"%d",&job[i].tr）;
}
printf（"输入作业顺序:
\n"）;
for（i=0;iprintf（"\t%d\t%d\t%d\n",job[i].no,job[i].tb,job[i].tr）;
}
voidfcfs_sjf（）
{
//********************************************************
inti,j,timeNow;
structJob_typet;
//冒泡排序，二级排序。
关键字：
作业开始时间，作业运行时间。
for（i=0;i{
for（j=0;j{
if（job[j].tb!
=job[j+1].tb）//作业开始时间不相等
{
if（job[j].tb>job[j+1].tb）
{
t=job[j];
job[j]=job[j+1];
job[j+1]=t;
}
}
else
{
if（job[j].tr>job[j+1].tr）
{
t=job[j];
job[j]=job[j+1];
job[j+1]=t;
}
}
}
}
//========================================================
printf（"FCFSsjf调度结果:
\n"）;
printf（"开始时间作业号到达时间运行时间完成时间等待时间周转时间\n"）;
//********************************************************
timeNow=0;
for（i=0;i{
printf（"\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",
timeNow,
job[i].no,
job[i].tb,
job[i].tr,
升级会员 