学进去

01 #include <iostream>
02
03 using namespace std;
04
05 int n, k;
06
07 int solve1()
08 {
09 int l = 0, r = n;
10 while (l <= r) {
11 int mid = (l + r) / 2;
12 if (mid * mid <= n) l = mid + 1;
13 else r = mid - 1;
14 }
15 return l - 1;
16 }
17
18 double solve2(double x)
19 {
20 if (x == 0) return x;
21 for (int i = 0; i < k; i++)
22 x = (x + n / x) / 2;
23 return x;
24 }
25
26 int main()
27 {
28 cin >> n >> k;
29 double ans = solve2(solve1());
30 cout << ans << ' ' << (ans * ans == n) << endl;
31 return 0;
32 }
假设int为为32位有符号整数类型，输入的n是不超过47000的自然数、k是不超过int表示范围的自然数，完成下面的判断题和单选题：
判断题
（1）该算法最准确的时间复杂度分析结果为0(logn +k)。(     )
（2）当输入为“9801 1”时，输出的第一个数为“99”。(     )
（3）对于任意输入的n，随着所输入k的增大，输出的第二个数会变成“1”。(     )
（4）该程序有存在缺陷。当输入的n过大时，第12行的乘法有可能溢出，因此应当将mid强制转换为64位整数再计算。(     )
单选题
（5）当输入为“21”时，输出的第一个数最接近(     )。
A.1              B.1.414              C.1.5              D.2
（6）当输入为“3   10”时，输出的第一个数最接近(     )。
A.1.7              B.1.732              C.1.75              D.2
（7）当输入为“256   11”时，输出的第一个数(     )。
A.等于16              B.接近但小于16              C.接近但大于16              D.前三种情况都有可能

01 #include <algorithm>
02 #include <iostream>
03 #include <limits>
04
05 using namespace std;
06
07 const int MAXN = 105;
08 const int MAXK = 105;
09
10 int h[MAXN][MAXK];
11
12 int f(int n, int m)
13 {
14 if (m == 1) return n;
15 if (n == 0) return 0;
16
17 int ret = numeric_limits<int>::max();
18 for (int i = 1; i <= n; i++)
19 ret = min(ret, max(f(n - i, m), f(i - 1, m - 1)) + 1);
20 return ret;
21 }
22
23 int g(int n, int m)
24 {
25 for (int i = 1; i <= n; i++)
26 h[i][1] = i;
27 for (int j = 1; j <= m; j++)
28 h[0][j] = 0;
29
30 for (int i = 1; i <= n; i++) {
31 for (int j = 2; j <= m; j++) {
32 h[i][j] = numeric_limits<int>::max();
33 for (int k = 1; k <= i; k++)
34 h[i][j] = min(
35 h[i][j],
36 max(h[i - k][j], h[k - 1][j - 1]) + 1);
37 }
38 }
39
40 return h[n][m];
41 }
42
43 int main()
44 {
45 int n, m;
46 cin >> n >> m;
47 cout << f(n, m) << endl << g(n, m) << endl;
48 return 0;
49 }
假设输入的 n 、m   均 是不超过 100   的 正整数 ，完成下面的判断题和单选题 ：
判断题
（1）当输入为“7 3”时，第19行用来取最小值的min函数执行了449次。(     )
（2）输出的两行整数总是相同的。(     )
（3）当m为1时，输出的第一行总为n。(     )
单选题
（4）算法g（n，m）最为准确的时间复杂度分析结果为(     )。
A. 0(n^3/2m)              B. 0(nm)              C. 0(n²m)              D. 0(nm²)
（5）当输入为“20 2”时，输出的第一行为(     )。
A.“4”              B.“5”              C.“6”              D.“20”
（6）当输入为“100   100”时，输出的第一行为(     )。
A.“6”              B.“7”              C.“8”              D.“9”

01 #include <iostream>
02
03 using namespace std;
04
05 int main()
06 {
07 unsigned short x, y;
08 cin >> x >> y;
09 x = (x | x << 2) & 0x33;
10 x = (x | x << 1) & 0x55;
11 y = (y | y << 2) & 0x33;
12 y = (y | y << 1) & 0x55;
13 unsigned short z = x | y << 1;
14 cout << z << endl;
15 return 0;
16 }
假设输入的x、y均是不超过15的自然数，完成下面的判断题和单选题：
判断题
（1）删去第7行与第13行的unsigned，程序行为不变。(     )
（2）将第7行与第13行的short均改为char，程序行为不变。(     )
（3）程序总是输出一个整数“0”。(     )
（4）当输入为“2 2”时，输出为“10”。(     )
（5）当输入为“2 2”时，输出为“59”。(     )
单选题
（6）当输入为“13 8”时，输出为(     )
A.“0”              B.“209”              C.“197”              D.“226”

以下对递归方法的描述中，正确的是（     ）

A．递归是允许使用多组参数调用函数的编程技术

B．递归是通过调用自身来求解问题的编程技术

C．递归是面向对象和数据而不是功能和逻辑的编程语言模型

D．递归是将用某种高级语言转换为机器代码的编程技术

一个字符串中任意个连续的字符组成的子序列称为该字符串的子串，则字符串abcab有（     ）个内容互不相同的子串。（     ）

A．12

B．13

C．14

D．15

八进制数32.1对应的十进制数是（     ）

A．24.125

B．24.250

C．26.125

D．26.250

以下排序算法的常见实现中，哪个选项的说法是错误的（     ）

A．冒泡排序算法是稳定的	B．简单选择排序是稳定的
C．简单插入排序是稳定的	D．归并排序算法是稳定的

以下哪组操作能完成在双向循环链表结点p之后插入结点s的效果（其中，next域为结点的直接后继，prev域为结点的直接前驱）（     ）

A．p->next->prev=s；s->prev=p；p->next=s；s->next=p->next；

B．p->next->prev=s；p->next=s；s->prev=p；s->next=p->next；

C．s->prev=p；s->next=p->next；p->next=s；p->next->prev=s；

D．s->next=p->next；p->next->prev=s；s->prev=p；p->next=s；

以下对数据结构的表述不恰当的一项为（     ）

A．图的深度优先遍历算法常使用的数据结构为栈

B．栈的访问原则为后进先出，队列的访问原则是先进先出

C．队列常常被用于广度优先搜索算法

D．栈与队列存在本质不同，无法用栈实现队列

考虑由N个顶点构成的有向连通图，采用邻接矩阵的数据结构表示时，该矩阵中至少存在（     ）个非零元素。（     ）

A．N-1

B．N

C．N+1

D．N2