单选题：
下列关于图的应用说法错误的是（C）
A
任何一个图的连通图的最小生成树有一棵或多棵；
B
某无向连通图中没有权值相同的边，该图的最小生成树唯一；
C
某无向图中有权值相同的边，则该图最小生成树一定不唯一；
D
可利用Prim算法和Kruskal两种算法来构造图的最小生成树；
2.
计算机系统中并发是对有限的物理资源强制行使多用户共享，消除计算机部件之间的互等现象，以提高系统资源利用率，现假设某单CPU系统中有输入和输出设备各1台，现有3个并发执行的作业，每个作业的输入、 计算和输出时间均分别为2ms、3ms和4ms,且都按输入、计算和愉出的顺序执行，则执行完3 个作业需要的时间最少是（ B）
A
18ms
B
17ms
C
22ms
D
23ms
FIFO为先进先出的顺序来完成页面的访问，而如果在采用先进先出页面淘汰算法的系统中，一进程在内存占3块（开始为空），页面访问序列为1、2、3、4、1、2、5、1、2、3、4、5、6。运行时会产生（ D ）次缺页中断？
A . 7
B .8
C.9
D.10
4.
二叉排序树又称为二叉查找树，在二叉排序树进行插入操作时,每次插入的结点都是二叉排序树上新的叶子结点，现假设分别用下列序列构造二叉排序树，与用其他三个序列所构造的结果不同的是（ D ）？
A
{100，70，40，90，140，150，110}
B
{100，70，90，40，140，110，150}
C
{100，140，110，150，70，40，90}
D
{100，40，70，90，140，110，150}
平常在设计数据结构的时候，经常会用到堆，以下哪个是最大堆 A
A
B
C
D
初始序列为1 2 3 4 5 6的完全二叉树，1为根节点，2，3分别为1的左右孩子，4，5分别为2的左右孩子，6为3的左孩子，采用大根堆调整后，堆所对应的中序遍历序列应为：A
A
4 5 2 6 1 3
B
6 5 4 3 2 1
C
6 5 4 2 3 1
D
4 2 5 1 3 6
有这样一个业务场景：一个请求需要一系列的处理工作,那么我们选择以下哪一种设计模式比较合适D
A
观察者模式
B
桥接模式
C
工厂模式
D
责任链模式
假设销售团队拥有一张账目表account,表中每行记录记录着销售员2016年到2018年每个月的销售额,如果销售员当月没有销售额,则不录入到表中,目前管理员想查看下2018年每个月都有销售额的销售人员的总销售额,
那么sql语句是: C
create table `account`(
`id` int(11) not null auto_increment,
`year` int(11) not null comment '年份',
`name` char(30) not null comment '销售员',
`month` int(11) not null comment '月份',
`sales` int(11) not null comment '销售额',
primary key(`id`)
)engine = innodb;
A
select name, sum(sales) from account where month = 12 and year = 2018 group by name having count(sales)=12 order by name asc
B
select name, sum(sales) from account where month = 12 group by name having year=2018 order by name asc
C
select name, sum(sales) from account where year = 2018 group by name having count(sales)=12 order by name asc
D
select name, sum(sales) from account group by name having year=2018 and count(sales)=12 order by name asc
在数据结构中，不同的排序方法决定了排序的时间效率，现在假设对关键字序列22、86、19、49、12、30、65、35、18做一趟排序后，得到的结果如下：18、12、19、22、49、30、65、35、86。因此，根据上述结果可以得到采用的排序方法是（ C）？
A
冒泡排序
B
快速排序
C
直接插入排序
D
堆排序
一个小根堆的序列为:{5, 12, 7, 18, 31, 13, 9}，删除根节点5之后，小根堆会自动调整重新变为小根堆，小根堆的最后的叶子节点为?B
A
31
B
13
C
9
D
12
E
18
先序遍历指按照根左右的顺序沿一定路径经过路径上所有的结点，现假设一颗二叉树的后序遍历为69, 67, 71, 70, 72, 68, 66, 中序遍历为69, 67, 66, 71, 70, 68, 72,则先序遍历为（ D）？
A
66, 67, 68, 69, 70, 71, 72
B
66, 67, 69, 68, 70, 71, 72
C
66, 69, 67, 70, 71, 72, 68
D
66, 67, 69, 68, 71, 70, 72
对于以下代码分析
void test(int N)
{
int i=1;
while(i<N)
{
i=i*4;
}
}
下面选项哪个最符合上面代码中循环执行的次数 C
A
0.5N
B
log2N
C
0.5log2N
D
0.2log2N
E
0.4log2N
以下程序存在何种安全漏洞？A
<tr>
<td class="font_content" align="right">交易状态：</td>
<td class="font_content" align="left"><?php echo $_GET['trade_status'];?></td>
</tr>
A
XSS
B
sql注入
C
命令执行
D
代码执行
多选题：
下面关于c++静态成员在类里面说法正确的有BDE
A
创建静态成员是为了方便对象能直接调用
B
静态成员函数里面不能使用该类的this指针
C
静态数据成员不受private控制符作用
D
静态成员函数的参数不能带有该类的this指针
E
静态成员函数不能被声明为virtual函数
看下面代码，关于运算符重载说法正确的有？BCE
class Time
{
private:
int minutes;
public:
Time operator+(const Time & t);
friend Time operator*(double clock,const Time &time);
};
A
若 Time operator+(const Time & t)重载正确，那么 Time t1; auto time= 22+t1;是一个正确的使用。
B
friend Time operator*(double clock,const Time &time)，这个函数可以访问Time类的minutes变量
C
friend Time operator*(double clock,const Time &time)，这个函数是一个非成员函数
D
friend Time operator*(double clock,const Time &time)，这个函数传入的参数可以是3个
E
"->"只能重载为类成员函数
下面关于STL 容器的capacity()和size()属性说法正确的是：ABD
A
size是当前vector容器真实占用的大小，capacity是指预分配的内存空间
B
使用reserve()可以修改capacity的值
C
vector、string 和set都拥有capacity()和size()属性
D
容器的size一旦超过capacity的大小，vector会重新配置内部的存储器
以下C++代码，那些语句会导致编译错误?AD
#include <iostream>
class Foo {
public:
explicit Foo(int a)
{
std::cout << "explicit Foo(int a)" << std::endl;
}
void func()
{
std::cout << "void func()" << std::endl;
}
private:
Foo(const Foo& foo)
{
std::cout << "Foo(const Foo& foo)" << std::endl;
}
};
int main()
{
Foo a;//1
Foo b();//2
Foo c(1);//3
Foo d = c;//4
return 0;
}
A.1
B.2
C.3
D.4
关于HTTP2描述正确的是ABC
A
采用文本格式创术数据
B
新增了多路复用
C
采用Header压缩
D
新增了连接的keep-alive功能
19.
修改/home下test目录以及目录下所有文件，可以支持所有人可读可写的，以下能实现的有?AB
A
chmod 777 /home/test -R
B
chmod 666 /home/test -R
C
chmod 766 /home/test
D
chmod 765 /home/test -R
20.
下列选项中，可能导致当前linux进程阻塞?AC
A
进程申请临界资源
B
该进程使用时间过长，进程调度程序让其他进程使用CPU
C
进程 从磁盘读数据
D
时间片用完了
编程题：
21.最小值
牛牛给度度熊出了一个数学题，牛牛给定数字\mathit n,m,kn,m,k，希望度度熊能找到一组非负整数\mathit a,ba,b满足(n-a)(m-b) \leq k(n−a)(m−b)≤k且\mathit a+ba+b尽量小。
度度熊把这个问题交给了你，希望你能帮他解决。
一行三个数字n,m,k 1<=n,m<=10^9,1<=k<=n*m
输出描述：输出最小的。
示例1
输入例子：
12 18 100
输出例子：
7
例子说明：
当\mathit a = 7, b = 0时候, (n-a)(m-b) = 90 \leq k = 100，此时\mathit a + b = 7是最小的解。
#include <iostream>
using namespace std;
int main()
{
double n,m,k;
while(cin>>n>>m>>k)
{
int count = 0;
if(n*m <=k)
cout<<0<<endl;
if(n>m)
swap(n,m);
while(n--)
{
count++;
if(n*m<=k)
{
break;
}
}
cout<<count<<endl;
}
return 0;
}
度度熊的工作
老板给度度熊分配了\mathit nn个工作，第\mathit ii个工作需要耗费a^i 单位时间，每个工作必须老板给定的限制时间b^i前完成。
度度熊从0时刻开始工作，在同一时间度度熊手上只能做一件工作，度度熊想知道他是否能把所有工作都完成呢？
输入描述：
第一行一个数表示数据组数。
每组数据第一行一个数。
接下来行每行两个数表示a_i,b_i。
输出描述：
每组数据输出一行，如果度度熊能完成他的工作输出"Yes"不然输出“No”。
示例1
输入例子：
1
5
2 4
1 9
1 8
4 9
3 12
输出例子：
Yes
例子说明：
从前往后依次做每个工作即可完成。
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
int k=0;
cin>>k;
for(int i=0;i<k;i++){
int n=0;
cin>>n;
vector<pair<int,int>> a;
for(int j=0;j<n;j++){
int x=0,y=0;
cin>>x>>y;
a.push_back({x,y});
}
sort(a.begin(),a.end(),[](pair<int,int> x1,pair<int,int> x2){
if(x1.second==x2.second) return x1.first<x2.first;
return x1.second<x2.second;
});
int time=0;
int j=0;
for(;j<n;j++){
time+=a[j].first;
if(time>a[j].second) break;
}
if(j==n) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
return 0;
}
树上游戏
牛牛和牛妹在做游戏，在他们面前的桌子上有一棵树，初始\text 11号点是黑点，\mathit nn号点是白点，其他都是空点，两人轮流操作，牛牛可以选择一个黑点并把该黑点周围的某个空点染成黑色，牛妹可以选择一个白点并把该白点周围的某个空点染成白色，直到有一方不能涂了，另一方获胜。
输入描述：
第一行一个数表示数据组数
每组数据第一行一个数表示树有个节点
接下来行每行个数，表示和点有一条边相连
输出描述：
每组数据对应一行，如果牛牛赢则输出”niuniu"，如果牛妹赢输出"niumei“。
示例1
输入例子：
2
7
3 6
1 2
3 1
7 4
5 7
1 4
4
1 4
4 2
2 3
输出例子：
niuniu
niumei
例子说明：
第一个用例树的形态如下：
第二个用例树的形态如下：
#include<iostream>
#include<vector>
#include<queue>
#include<unordered_map>
#include<unordered_set>
using namespace std;
struct node {
int cur_node;
int pre_node;
int deep;
node(int a, int b, int c) :cur_node(a), pre_node(b), deep(c) {}
node():cur_node(0),pre_node(0),deep(0){}
};
pair<int, int> find_way(vector<vector<int>>& map, int n) // 寻找边界节点
{
queue<node> queue;
node tmp(0, -1, 0);
queue.push(tmp);
unordered_map<int, node> visited;
visited[0] = tmp;
while (!queue.empty())
{
tmp = queue.front();
queue.pop();
if (tmp.cur_node == n - 1) // 到达节点n终止bfs
break;
for (int i = 0; i < map[tmp.cur_node].size(); i++)
{
int t = map[tmp.cur_node][i];
if (t == 0)
continue;
if (visited.find(i) != visited.end())
continue;
node next(i, tmp.cur_node, tmp.deep + 1);
visited[i] = next;
queue.push(next);
}
}
node fin_node = visited[n - 1]; // 倒推回去找途径的节点
int op_num = (fin_node.deep - 1) / 2; //计算牛妹拥有的节点数
int cnt = 0;
node cur = fin_node;
while (cnt != op_num)
{
int pre_num = cur.pre_node;
cnt++;
cur = visited[pre_num];
}
return pair<int, int>(cur.cur_node, cur.pre_node); // 返回牛牛和牛妹的边界节点
}
int bfs(vector<vector<int>>& map, int start, int bound, int n) //计算两人各拥有的空白节点数
{
unordered_set<int> visited;
queue<int> queue;
int cnt = 0;
queue.push(start);
visited.insert(start);
while (!queue.empty())
{
int cur_node = queue.front();
queue.pop();
for (int i = 0; i < map[cur_node].size(); i++)
{
int t = map[cur_node][i];
if (t == 0 || i == bound)
continue;
if (visited.find(i) != visited.end())
continue;
cnt++;
visited.insert(i);
queue.push(i);
}
}
return cnt;
}
int main()
{
int T;
cin >> T;
for (int tt = 0; tt < T; tt++)
{
int n;
cin >> n;
vector<vector<int>> map(n);
int x, y;
for (int i = 0; i < n - 1; i++) // 建无向图
{
cin >> x >> y;
map[x - 1].emplace_back(y - 1);
map[y - 1].emplace_back(x - 1);
}
auto bound_node = find_way(map, n);
int niuniu = bfs(map, 0, bound_node.first, n);
int niumei = bfs(map, n - 1, bound_node.second, n);
if (niuniu > niumei)
cout << "niuniu" << endl;
else cout << "niumei" << endl;
}
}
2993
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
