题目内容

●试题三
上网浏览前在局域网中应如何对IE进行设置？

查看答案

搜索结果不匹配？点我反馈

更多问题

●试题五
什么是防火墙，有哪些类型，比较它们在维护网络安全方面的优缺点。

●试题五
阅读下列程序说明和C代码，将应填入(n)处的字句写在答题纸的对应栏内。
【程序5说明】
著名的四色定理指出任何平面区域图均可用四种颜色着色，使相邻区域着不同的颜色。本程序对给定的区域图找出所有可能的不超过四种颜色的着色方案。
程序中用1~4表示四种颜色。要着色的N个区域用0~N-1编号，区域相邻关系用adj［］［］矩阵表示，矩阵的i行j列的元素为1，表示区域i与区域j相邻；矩阵的i行j列的元素为0，表示区域i与区域j不相邻。数组color［］用来存储着色结果，color［i］的值为区域i所着颜色。
【程序5】
#include＜stdio.h＞
#define N 10
void output(int color［］)/输出一种着色方案/
{int i;
for(i=0;i＜N;i++)
printf("%4d"，color［i］);
printf("＼n");
}
int back(intip,int color［］)/回溯/
{int c=4;
while(c==4){
if(ip＜=0)return 0;
--(ip);
c= (1) ;
color［ip］=-1;
}
return c;
}
/检查区域i，对c种颜色的可用性/
int color0k(int i,int c,int［］［N］,int color［］}
{int j;
for(j=0;j＜i;j++)
if((2) )
return 0;
return 1;
}
/为区域i选一种可着的颜色/
int select(int i,int c,int adj［］［N］,int color［］)
{int k;
for(k=c;k＜=4;k++)
if(colorOK((3) ))
return k;
return 0;
}
int coloring(int adj［］［N］)/寻找各种着色方案/
{int color［N］,i,c,cnt;
for(i=0;i＜N;i++)color［i］=-1;
i=c=0;cnt=0;
while (1) {
if((c= (4) )==0){
c=back(&i,color);
if(c==0)return cnt;
}else{ (5) ;i++;
if(i==N){
output(color);
++cnt;
c=back(&i,color);
}else c=0;
}
}
}
void main()
{int adj［N］［N］=
{{0，1，0，1，1，1，1，1，1，1},
{1，0，1，1，0，1，1，1，1，0},
{0，1，0，1，0，1，1，0，1，1},
{1，1，1，0，1，1，0，0，1，1},
{1，0，0，1，0，1，0，0，0，0},
{1，1，1，1，1，0，1，0，0，1},
{1，1，1，0，0，1，0，0，1，0},
{1，1，0，0，0，0，0，0，1，1},
{1，1，1，1，0，0，1，1，0，1},
{1，0，1，1，0，1，0，1，1，0}
}；
printf("共有%d组解.＼n",coloring(adj));
}

●试题五
阅读下列程序说明，将应填入(n)处的字句写在答卷纸的对应栏内。
【程序说明】
对于一个公司的雇员来说，无非有3种：普通雇员、管理人员和主管。这些雇员有共同的数据：名字、每小时的工资，也有一些共同的操作：数据成员初始化、读雇员的数据成员及计算雇员的工资。但是，他们也有不同。例如，管理人员除有这些共同的特征外，有可能付固定薪水，主管除有管理人员的共同特征外，还有其他物质奖励等。3种雇员中，管理人员可以看作普通雇员的一种，而主管又可以看作管理人员的一种。我们很容易想到使用类继承来实现这个问题：普通雇员作为基类，管理人员类从普通雇员类中派生，而主管人员类又从管理人员类中派生。
下面的程序1完成上述各个类的定义，并建立了3个雇员(一个普通雇员、一个管理人员和一个主管)的档案，并打印出各自的工资表。将"程序1"中的成员函数定义为内联函数，pay成员函数定义为虚函数，重新完成上述要求。
【程序1】
//普通雇员类
class Employee
{
public：
Employee(chartheName，float thePayRate)；
chargetName()const；
float getPayRate()const；
float pay(float hoursWorked)const；
protected：
charname；//雇员名称
float payRate；//薪水等级
};
Employee::Employee(chartheName，float thePayRate)
{
name=theName；
payRate=thePayRate；
}
charEmployee::getName() const
{
return name；
}
float Employee::getPayRate()const
{
return payRate；
}
float Employee::pay(float hoursWorked)const
{
return hoursWorkedpayRate；
}
//管理人员类
class Manager∶public Employee
{
public：
//isSalaried付薪方式：true付薪固定工资，false按小时付薪
Manager(chartheName，float thePayRate，bool isSalaried)；
bool getSalaried()const；
float pay(float hoursWorked)const；
protected：
bool salaried；
}；
Manager::Manager(chartheName，float thePayRate，bool isSalaried)
∶Employee(theName，thePayRate)
{
salaried=isSalaried；
}
bool Manager::getSalaried() const
{
return salaried；
}
float Manager::pay(float hoursWorked)const
{
if(salaried)
return payRate；
/else/
return Employee::pay(hoursWorked)；
}
//主管人员类
class Supervisor：public Employee
{
public：
Supervisor(chartheName，float thePayRate，float theBouns)：
Employee(theName，thePayRate， (1) )，bouns(theBouns){}
float getBouns()const{return bouns；}
float pay(float hoursWorked)const
return (2) ；
}
protected：
float bouns；
}
#include"iostream.h"
void main()
{
Employee e("Jack"，50.00)；
Manager m("Tom"，8000.00，true)；
Supervior s("Tanya"，8000.00，8000.00)；
cout＜＜"Name:"＜＜e.getName()＜＜endl；
cout＜＜"Pay："＜＜e.pay(80)＜＜endl；//设每月工作80小时
cout＜＜"Name："＜＜m.getName()＜＜endl；
cout＜＜"Pay："＜＜m.pay (40) ＜＜endl；
cout＜＜"Name："＜＜s.getName()＜＜endl；
cout＜＜"Pay："＜＜s.pay (40) ＜＜endl；//参数40在这里不起作用
}
【程序2】
#include"employee.h"
//普通雇员类
class Employee
{
public：
//构造函数
Employee(string theName，float thePayRate)：
name(theName)，payRate(thePayRate){}
//取雇员姓名
string getName() const{returnname；}
//取雇员薪水等级
float getPayRate()const{return payRate；}
//计算雇员薪水
virtual float pay(float hoursWorked)const{return (3) ;}
protected：
string name；//雇员名称
float payRate；//薪水等级
};
//管理人员类
//继承普通雇员类
class Manager：public Employee
{
public：
//构造函数
//isSalaried标识管理人员类的付薪方式
//true 按阶段付薪(固定工资)
//false按小时付薪
Manager(string theName，float thePayRate，bool isSalaried)：
Employee(theName，thePayRate)，salaried(isSalaried){}
//取付薪方式
bool getSalaried()const{return salaried；}
//计算薪水
virtual float pay(float (4) )const；
protected：
bool salaried；
}；
float Manager::pay(float hoursWorked)const
{
if(salaried)//固定付薪方式
return payRate；
else//按小时付薪
return (5) ； }
//主管人员类
class Supervisor： (6)
{
public：
//构造函数
Supervisor(string theName，float thePayRate，float theBouns)：
Manager(theName，thePayRate，true)，bouns(theBouns){}
//取奖金数额
float getBouns()const{return bouns；}
//计算薪水
virtual float pay(float hoursWorked)const
{
retum payRate+bouns；
}
(7)
float bouns；
}
#include"employee.h"
#include"iostream.h"
void main()
{
(8) ep[3]；ep[0]=new Employee("Jack"，"50.00")；
ep[1]=new Manager("Tom"，"8000.00"，true)；
ep[2]=new Supervior("Tanya"，"8000.00"，"8000.00")；
for(int i=0；i＜3;i++){
cout＜＜"Name："＜＜ (9) ＜＜endl；
cout＜＜"Pay："＜＜ (10) ＜＜endl；//设每月工作80小时
}
}

●试题六
阅读以下说明和C++代码，将应填入(n)处的字句写在答题纸的对应栏内。
【说明】
本题将有向网(带权有向图)定义为类AdjacencyWDigraph。类中的数据成员n表示有向网中的顶点数;a为带权邻接矩阵，用于存储有向网中每一对顶点间弧上的权值;c为二维数组，存储有向网中每一对顶点间的最短路径长度;kay为二维数组，存储最短路径，kay［i］［j］=k表示顶点i 到达顶点j的最短路径必须经过顶点k。类中的主要成员函数有：
Input():输入有向网的顶点数、各条弧及权值，建立带权领接矩阵a。若顶点i到顶点j有弧，则a［i］［j］取弧上的权值，否则a［i］［j］的值取NoEdge。
AllPairs();用弗洛伊德(Floyd)算法求有向网中每一对顶点间的最短路径长度。
OutShortestPath(int i,int j):计算顶点i到顶点j的最短路径。
outputPath(int i,int j):输出顶点i到顶点j的最短路径上的顶点。
Floyd算法的基本思想是递推地产生一个矩阵序列C0,C1，C2，…，Cn,其中C0是已知的带权邻接矩阵，a,Ck(i,j)(0≤i,j＜n)表示从顶点i到顶点j的中间顶点序号不大于k 的最短路径长度。如果i到j的路径没有中间顶点，则对于0≤k＜n,有Ck(i,j)=C0(i,j)=a［i］［j］。递推地产生C1，C2，…，Cn的过程就是逐步将可能是最短路径上的顶点作为路径上的中间顶点进行试探，直到为全部路径都找遍了所有可能成为最短路径上的中间顶点，所有的最短路径也就全部求出，算法就此结束。
【C++代码】
#include＜iostream．h＞
＃define NoEdge 10000 //当两个顶点之间没有边相连时，在邻接矩阵中用NoEdge表示
void Make2DArray(int * * &x,int rows,int cols);
class AdjacencyWDigraph{
private
int n;//有向网中的顶点数目
inta;//存储顶点间弧上的权值
intc;//存储计算出的最短路径长度
intkay;//存储求出的最短路径
pubic:
int Vertices()const {return n;}
void AllPairs();
void Input();//输入有向网的顶点数、各条弧及权值，建立邻接矩阵a
void OutShortestPath(int i,int j);//计算顶点i到j的最短路径(试卷中未列出)
~AdjacencyWDigraph();//析构函数(试卷中未列出)
private:
void outputPath(int i,int j);
};
void AdjacencyWDigraph::AllPairs()
{int i,j,k,t1,t2,t3;
for(i=1;i＜=n;k++)
for(j=1;j＜=n;++j)
{c［i］［j］= (1) ;kay［i］［j］=0;}
for(k=1;k＜=n;k++)
for(i=1;i＜=n;i++){
if(i==k) continue;
t1=c［i］［k］;
for(j=1;j＜=n;j++){
if(j==k||j==i)continue;
t2=c［k］［j］;t3=c［i］［j］;
if(t1!=NoEdge && t2!=NoEdge &&(t3==NoEdge||t1+t2＜t3))
{c［i］［j］= (2) ；kay［i］［j］= (3) ;}
}//for
}//for
}
void AdjacencyWDigraph:: outputPath(int i,int j)
{//输出顶点i到j的最短路径上的顶点
if(i==j)return;
if(kay［i］［j］==0)cout＜＜j＜＜′′;
else { outputPath(i, (4) ); outputPath((5) );}
}
void Adjacency WDigraph::Input()
{int i,j,u,v,w,E;
cout＜＜″输入网中顶点个数：″;cin＞＞n;
cout＜＜″输入网中弧的个数:″;cin＞＞E;
Make2DArray(a,n+1,n+1);
for(i=1;i＜=n;i++)
for(j=1;j＜=n;j++)a［i］［j］=NoEdge;
for(i=1;i＜=n;i++)a［i］［i］=0;
Make2DArray(c,n+1,n+1);
Make2DArray(kay,n+1,n+1);
for(i=1;i＜=E;i++){
cout＜＜″输入弧的信息(起点终点权值)：″；cin＞＞u＞＞v＞＞w;a［u］［v］=w;
}
}
void Make2DArray(int&x,int rows,int cols)
{int i,j;
x=new int*［rows+1］;
for(i=0;i＜rows+1;i++)x［i］=new int ［cols+1］;
for(i=1;i＜=rows;i++)
for(j=1;j＜=cols;j++＝x［i］［j］=0;
}