已知⼩写字母 b 的ASCII码为98 ，下列C++代码的输出结果是（  ）。

#include  <iostream>   
using  namespace  std ; 
int  main()  {
    char  a  =   'b '  +  1; 
    cout  <<  a ;
    return  0 ; }

已知 a 为 int 类型变量 ，  p 为 int  * 类型变量 ，下列表达式不符合语法的是（  ）。

下列关于C++类的说法 ，错误的是（  ）。

已知数组 a 的定义 int  a [10]  =  {-1} ;  ，下列说法不正确的是（  ）。

一棵完全⼆叉树有165个结点;，则叶结点有多少个？

下列关于⼆叉树的说法 ，错误的是（  ）。

下列关于树和图的说法 ，错误的是（  ）。

对一个包含V个顶点、E条边的图 ，执⾏⼴度优先搜索 ，其最优时间复杂度是（  ）。

以下哪个⽅案不能合理解决或缓解哈希表冲突（  ）。

以下关于贪⼼法和动态规划的说法中 ，错误的是（  ）。

下⾯C++程序的输出为（  ）。

#include  <iostream>   
using  namespace  std ;
int  fib(int  n )  {
    if  (n  ==  0 )
        return  1;
    return  fib(n  -  1 )  +  fib(n  -  2 ) ; }
int  main()  {
    cout  <<  fib(6 )  <<  endl;
    return  0 ; 
}

下⾯C++程序的时间复杂度为（  ）。

int  rec_fib [MAX_N ] ;
int  fib(int  n )  {
    if  (n  <=  1 )
        return  n ;
    if  ( rec_fib [n ]  !=  0 )
        return  rec_fib [n ] ;
    return  fib(n  -  1 )  +  fib(n  -  2 ) ; 
}

下⾯ init_sieve 函数的时间复杂度为(  )。

int  sieve [MAX_N ] ;
void  init_sieve(int  n )  {
    for  (int  i  =  1;  i  <=  n ;  i++)
        sieve [i ]  =  i;
    for  (int  i  =  2;  i  <=  n ;  i++)
        for  (int  j  =  i;  j  <=  n ;  j  +=  i )
            sieve [j] - - ; 
}

下⾯ count_triple 函数的时间复杂度为(  )。

int  gcd(int  m ,  int  n )  {
     if  (m  ==  0 )
     eturn  n ; return  gcd(n  %  m ,  m ) ;
}
int  count_triple(int  n )  {
int  cnt  =  0 ;
    for  (int  v  =  1;  v  *  v  *  4  <=  n ;  v++)
        for  (int  u  =  v  +  1;  u  *  (u  +  v )  *  2  <=  n ;  u  +=  2 )
            if  (gcd(u ,  v )  ==  1 )  {
            int  a  =  u  *  u  –  v  *  v;
            int  b  =  u  *  v  *  2;
            int  c  =  u  *  u  +  v  *  v;
            cnt  +=  n  /  (a  +  b  +  c ) ; 
          }
    return  cnt ;
}

下列选项中，哪个不可能是下图的深度优先遍历序列（ ）。

C++语⾔中 ，表达式 9  &&  12 的结果类型为 int 、 值为 8 。

C++语⾔中 ，在有 int  a [10] ; 定义的范围内 ，通过表达式 a [-1] 进⾏访问将导致编译错误。

选择排序一般是不稳定的

C++语⾔中 ， float 和 int 类型一般都是 4 字节 ， 因此 float 类型能够表达不同的浮点数值的数量 ，与 int 类型能够表达不同的整数值的数量是相同的。

使⽤ math .h 或 cmath 头⽂件中的对数函数 ，表达式 log(256) 的结果类型为 double 、 值约为 8 .0 。

邻接表和邻接矩阵都是图的存储形式 。通常 ，使⽤邻接表⽐使⽤邻接矩阵的时间复杂度更低。

C++语⾔中 ，类的构造函数可以声明为私有（private）。

泛洪算法的递归实现容易造成溢出 ， 因此⼤的⼆维地图算法中 ，一般使⽤⼴度优先搜索实现。

试题名称：连通图

时间限制： 1.0 s

内存限制：512.0 MB

3.1.1     题目描述

给定一张包含 n 个结点与 m 条边的⽆向图 ，结点依次以 1,2, ...n 编号 ，第 i 条边（ 1 ≤ i ≤ m）连接结点 u_i 与结点 v_i 。如果从一个结点经过若⼲条边可以到达另一个结点 ，则称这两个结点是连通的。

你需要向图中加⼊若⼲条边 ，使得图中任意两个结点都是连通的 。请你求出最少需要加⼊的边的条数。

注意给出的图中可能包含重边与⾃环。

3.1.2     输入格式

第一⾏ ，两个正整数 n, m ，表⽰图的点数与边数。

接下来 m ⾏ ，每⾏两个正整数 u_i , v_i ，表⽰图中一条连接结点 u_i 与结点  v_i 的边。

3.1.3     输出格式

输出一⾏ ，一个整数 ，表⽰使得图中任意两个结点连通所需加⼊的边的最少数量。

3.1.4     样例

3.1.4.1     输入样例 1

4 4

1 2

2 3

3 1

1 4

3.1.4.2     输出样例 1

0

3.1.4.3     输入样例 2

6  4

1  2

2  3

3  1

6  5

3.1.4.4     输出样例 2

2

3.1.5     数据范围

对于 40% 的测试点 ，保证 1 ≤ n ≤ 100 ，1  ≤ m ≤ 100。

对于所有测试点 ，保证 1 ≤ n ≤ 10⁵ ，1  ≤ m ≤ 10⁵ 。

试题名称：⾦币收集

时间限制： 1.0 s

内存限制：512.0 MB

3.2.1     题目描述

⼩ A 正在游玩收集⾦币的游戏 。具体来说 ，在数轴上将会出现 n 枚⾦币 ，其中第 i 枚（ 1 ≤ i ≤ n）⾦币将会在时刻 t_i 出现在数轴上坐标为 x_i 的位置 。⼩ A 必须在时刻 t_i 恰好位于坐标 x_i ，才可以获得第 i 枚⾦币。

游戏开始时为时刻 0 ，此时⼩ A 的坐标为 0 。正常来说 ，⼩ A 可以按游戏机的按键在数轴上左右移动 ，但不幸的是 游戏机的左⽅向键失灵了 。⼩ A 每个时刻只能选择保持不动 ，或是向右移动一个单位 。换⾔之 ，如果⼩ A 在时刻 t 的坐标为  x，那么他在时刻 t + 1 的坐标只能是  x或是  x+ 1 ⼆者之一 ，分别对应保持不动和向右移动。

⼩ A 想知道他最多能收集多少枚⾦币 。你能帮他收集最多的⾦币吗？

3.2.2     输入格式

第一⾏ ，一个正整数 n ，表⽰⾦币的数量。

接下来 n ⾏ ，每⾏两个正整数 x_i , t_i ，分别表⽰⾦币出现的坐标与时刻。

3.2.3     输出格式

输出一⾏ ，一个整数 ，表⽰⼩ A 最多能收集的⾦币数量。

3.2.4     样例

3.2.4.1     输入样例 1

3

1 6

3 7

2 4

3.2.4.2

1  2

3.2.4.2 输出样例 1

2

输入样例 2

4

1  1

2  2

1  3

2  4

3.2.4.4     输出样例 2

3

3.2.5     数据范围

对于 40% 的测试点 ，保证 1 ≤ n ≤ 8。

对于另外 30% 的测试点 ，保证 1 ≤ n ≤ 100 ，1  ≤ x_i ≤ 100 ，1 ≤ t_i ≤ 100。 

对于所有测试点 ，保证 1  ≤ n ≤ 10⁵ ，1  ≤ x_i ≤ 10⁹ ，1 ≤ t_i  ≤ 10⁹ 。