阅读下列函数说明和C代码，将应填入(n)外的字句写在对应栏内。

 [说明]

 为网球比赛的选手安排比赛日程。设有n(n=2m)位选手参加网球循环赛，循环赛共进行n-1天，每位选手要与其他n-1位选手赛一场，且每位选手每天赛一场，不轮空。

 设n位选手被顺序编号为1，2，…，n，比赛的日程表是一个n行n-1列的表，第i行j列的内容是第i号选手第j天的比赛对手。用分治法设计日程表，就是从其中一半选手(2m-1位)的比赛日程导出全体2m选手的比赛日程。从众所周知的只有两位选手的比赛日程出发，反复这个过程，直至为n位选手安排好比赛日程为止。

 如两位选手比赛日程表如下所示：

如四位选手比赛日程表如下所示：

 函数中使用的预定义符号如下：

 #define M 64

 int a[M+1][M];

 [函数]

 voidd main(){

 int twoml,twom,i,j,m,k;

 printf("指定n(=2的k次幂)位选手，请输入k：\n");

 scanf("%d",＆k);

 /*8预设两位选手的比赛日程*/

 a[1][1] =2;

 a[2][1] =1;

 m=1;

 twoml=1;

 while ( (1) ){

 m++;

 twoml+=twoml;

 twom=twoml*2;/*为2^m位选手安排比赛日程*/

 /*填日程表的左下角*/

 for(i=twoml+1; (2) ;i++){

 for(j=1; j<=twoml-1; j++){

 a[i][j]=a[i-twoml][j]+twoml;

 }

 }

 /*填日程表的右上角*/

 a[1][twoml]= (3) ;/+填日程表右上角的第1列*/

 for(i=2; i<=twoml; i++){

 a[i][twoml]=a[i-1][twoml]+1;

 }

 /*填日程表右上角的其他列，参照前一列填当前列*/

 for(j=twoml+1; j(twom;j++){

 for(i=1; i  a[i][j]= (4) ;

 }

 a[twoml][j]=a[1][j-1];

 }

 /*填日程表的右下角*/

 for(j=twoml; j  for(i=1;i<=twoml; i++){

 a[ (5) [j]=i;

 }

 }

 /*输出日程表*/

 for(i=1; i<=twom; i++){

 for(j=1;j  printf("%4d",a[i][j]);

 }

 printf("\n");

 }

 printf("\n");

 }

 }

(1)

(5)

(3)

(4)

阅读以下函数说明和Java代码，将应填入(n)处的字句写在对应栏内。

 [说明]

 很多时候，希望某些类只有一个或有限的几个实例，典型解决方案是所谓单身(Singleton)模式。但在多线程情况下，Singleton模式有可能出现问题，需要进行同步检查。如果对“检查singleton对象是否已经创建”进行同步，则存在严重的瓶颈，所有的线程都必须等待检查对象是否存在。解决方式是一种称为Double-Checked-Locking模式，其意图是将非必须的锁定优化掉，同步检查最多只发生一次，因此不会成为瓶颈。以下是Java语言实现，能够正确编译通过。

 [Java代码]

 public class USTax {

 private static USTax instance=null;

  (1) USTax(){}

 private (2) static void doSync(){

 if(instance==null){

 System.out.println("实例不存在，创建实例..");

 instance=(3);

 System.out.println("实例创建成功");

 }else{

 System.out.println("实例已被创建了");

 }

 }

 public static USTax getInstance(){

 if(instance==null){

 System.out.println("实例暂时不存在");

  (4);//同步控制

 }else{

 System.out.println("实例已经存在");

 }

 return (5);

 }

 }

(1)

(5)

(2)

(3)

(4)

(5)

阅读以下说明和c++代码，将应填入(n)处的字句写在答题纸对应栏内。

 [说明]

 很多时候，希望某些类只有一个或有限的几个实例，典型解决方案是所谓单身(Singleton)模式。但在多线程情况下，Singleton模式有可能出现问题，需要进行同步检查。如果对“检查Singleton对象是否已经创建”进行同步，则存在严重的瓶颈，所有的线程都必须等待检查对象是否存在。解决方式是一种称为Double-Checked-Locking模式，其意图是将非必须的锁定优化掉，同步检查最多只发生一次，因此不会成为瓶颈。以下是c++语言实现，能够正确编译通过。

 [C++代码]

 class USTax{

  (1):

 USTax(){};//构造函数

 public:

 static USTax* getInstance();

 private:

 static USTax*instance;

 };

  (2)=NULL;

 USTax*USTax::get Instance(){

 if(instance==NULL){

 //进行某种同步

 cout<<"实例暂时不存在"<  if( (3) ){

 cout<<"实例不存在，创建实例..."<  instance=(4);

 cout<<"实例创建成功"<  }

 else{

 cout<<"实例已被创建了"<  }

 }

 else{

 cout<<"实例已经存在"<  }

 return (5);

 }

(1)