test

最新推荐文章于 2023-04-06 08:32:46 发布
最新推荐文章于 2023-04-06 08:32:46 发布
阅读量1.3k 收藏 4
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PUBG___/article/details/102595239
版权

CCF 2019CSP-S初赛模拟试题
提高组C++语言
竞赛时间:2019年10月
选手注意:
●  试题纸共有10页，答题纸共有2页，满分100分。请在答题纸上作答，写在试题纸上的一律无效。
●  不得使用任何电子设备(如计算器、手机、电子词典等)或查阅任何书籍资料。
C C A D B B C B A D 
一、单项选择题(共15题，每题2分，共计30分；每题有且仅有一个正确选项)
1.以下关于CSP-J/S的描述错误的是（）
A.任何人都可以自愿报名参加CSP-J/S
B.CSP-J/S是CCF独立主办的认证，和任何其他机构主办的等级考试无关
C.CSP-J/S和NOIP有密切关系
D.CSP-J/S认证成绩优异者，可参加NOI省级选拔，省级选拔成绩优异者可参加NOI

2.-128的补码表示为()
A.00000000        B.00000001        C.10000000        D.11111111

3.    以下不属于TCP拥塞控制算法的是()
A.    慢启动            B.拥塞避免            C.快启动        D.快速重传

4.    以下不是基于UDP协议的是()
A.DNS                B.RIP                C.TELNET            D.TFTP

5.    定义如下函数add_edge和全局变量：
int to[MAX],nxt[MAX],h[MAX],top;
void add_edge(int u,int v){
    to[++top]=v,nxt[top]=h[u],h[u]=top;
}
如下图节点编号从1开始，按边的编号顺序，以前向星的方式存储，请问nxt[h[3]]的值为（）
 
A.6            B.3           C.8             D.7

6.    如下图所示，从节点1走6步走到节点5的方案数有多少种（）
 

A.5        B.8            C.7            D.6
7.同时查找 2n 个数中的最大值和最小值，最少比较次数为( )。
A.3(n-2)/2        B.3n-2        C.4n-2        D.2n-2

8.设 A 和 B 是两个长为 n 的有序数组，现在需要将 A 和 B 合并成一个排好序的 数组，请问任何以元素比较作为基本运算的归并算法最坏情况下至少要做 ( )次比较。
A.n2                B.nlog2n            C.2n        D.2n-1

9.G 是一个非连通简单无向图，共有 36 条边，则该图至少有( )个顶点
A.10            B.9            C.8        D.7

10.由四个不同的点构成的简单无向连通图的个数是( )
A.32            B.35            C.38        D.31


11.前缀表达式- + * 4 + 2 3 1 5的值为（）
A.16            B.17            C.19        D.15

12.2+3*(4-(5+6))/7的逆波兰表达式为（）
A.2 3 4 5 6 - + * 7 / +
B.2 3 4 5 6 - + * / 7 +
C.2 3 4 5 6 + - * 7 / +
D.2 3 4 5 6 + + * / 7 -

13.若某算法的计算时间表示为递推关系：
 
则该算法的复杂度为()
A.             B.             C.             D. 

14.若某算法的计算时间表示为递推关系：
 
则该算法的复杂度为()
A.             B.             C.             D. 

15. 现有变量a,b,c,d，取值范围均为[0,15]，假设每个值出现的概率相同，则表达式 的值能被3整除的概率（  ）( 为计算机中的异或运算符，结果用分数形式表达)
A．3/8            B.1/2                    C.1/4                D.1/8

二、阅读程序写结果(共4题，每题10分，共计40分)
1.
#include<iostream>
using namespace std;
int a,b,c;

int* cal(int *p,int &q,int r){
    q+=r;
    *p+=q;
    return p;
}

int main(){
    cin>>a>>b>>c;
c=*cal(&a,b,c);
    cout<<a<<" "<<b<<" "<<c;
}
1.1 cal函数中参数p使用指针传递，q和r则是值传递
A.正确
B.错误

1.2 cal函数返回一个指向int类型存储空间的地址
A.正确
B.错误

1.3 当输入1 2 3时，程序输出结果为（）
A.6 2 3
B.6 5 3
C.6 5 6
D.1 2 6

1.4 当输入23 45 11时，程序的输出结果为（）
A.79 56 11
B.79 56 79
C.44 56 79
D.79 56 44

2.
#include<iostream>
#include<cmath>
#define MAX 1000
#define p sqrt(3)
using namespace std;
int n,dp[1000][3];
int h0=1,h1=3;
double ans1=(2+p)/(2*p),ans2=(-2+p)/(2*p);
int main(){
    cin>>n;
    dp[1][0]=dp[1][1]=dp[1][2]=1;
    for(int i=2,tmp;i<=n;i++){
        dp[i][0]=dp[i-1][1]+dp[i-1][2];
        dp[i][1]=dp[i-1][0]+dp[i-1][1]+dp[i-1][2];
        dp[i][2]=dp[i-1][0]+dp[i-1][1]+dp[i-1][2];
        tmp=h1;
        h1=2*(h1+h0);
        h0=tmp;
    }
    for(int i=1;i<=n;i++){
        ans1=ans1*(1+p);
        ans2=ans2*(1-p);
    }
    cout<<h1<<endl;
    cout<<dp[n][0]+dp[n][1]+dp[n][2]<<endl;
    cout<<ans1+ans2<<endl;
}
2.1 上述程序的输出中h1和dp[n][0]+dp[n][1]+dp[n][2]的值相等
A.正确
B.错误

2.2 上述程序的输出中dp[n][0]+dp[n][1]+dp[n][2]和ans1+ans2的值相等
A.正确
B.错误

2.3 当n等于5时，第一行输出（即h1）结果为（ ）
A.164
B.60
C.448
D.128

2.4 当n等于10时，第三行输出（即ans1+ans2）结果为（）
A.9136
B.68192
C.24960
D.3344


3.
#include<iostream>
#include<cstring>
#define LL long long
using namespace std;
LL l,r;
LL f[12][10][10][2][2][2],a[20];
LL Dfs(LL now,LL p,LL pp,LL _4,LL _8,LL top,LL hw){
    if(_4&&_8) return 0;
    if(!now) return hw;
    if(!top && f[now][p][pp][_4][_8][hw]!=-1) return f[now][p][pp][_4][_8][hw];
    LL Up=top?a[now]:9;
    LL ret(0);
    for(LL i=0;i<=Up;++i)
        ret+=Dfs(now-1,i,p, _4|(i==4),_8|(i==8), top&&(i==Up) ,hw|(i==pp&&i==p));
    if(!top) f[now][p][pp][_4][_8][hw]=ret;
    return ret;
}
inline LL Solve(LL x){
    LL tot(0);
    while(x){
        a[++tot]=x%10;
        x/=10;
    }
    if(tot!=11) return 0;
    LL ret(0);
    for(LL i=1;i<=a[tot];++i)
        ret+=Dfs(tot-1,i,0,(i==4),(i==8),i==a[tot],0);
    return ret;
}
int main(){
    cin>>l>>r;
    memset(f,-1,sizeof(f));
    cout<<Solve(r)-Solve(l-1);
    return 0;
}
3.1 同时包含4和8的数字都不会被统计
A.正确
B.错误

3.2 相邻数位中，超过3个数位相同的数字都不会被统计
A.正确
B.错误

3.3 下列哪个是合法（会被统计）的数字（）
A.2323234823
B.1015400080
C.23333333333
D.10010012022

3.4当输入12121284000 12121285550时，程序输出结果为（）
A.5
B.457
C.455
D.6


4.
#include <iostream>
#include <string>
 
using namespace std;
 
size_t equalizeLength(string &s1, string &s2)
{
    size_t len1 = s1.size(), len2 = s2.size();
    if (len1 < len2)
    {
        for (int i = 0; i < len2 - len1; ++i)
            s1 = '0' + s1;
        return len2;
    }
    else if (len1 > len2)
    {
        for (int i = 0; i < len1 - len2; ++i)
            s2 = '0' + s2;
    }
    return len1;
}
 
string strAddition(string s1, string s2)
{
    string ret;
    int carry = 0;
    size_t len = equalizeLength(s1, s2);
    
    for (int i = len - 1; i >= 0; --i)
    {
        int firstBit = s1.at(i) - '0';
        int secondBit = s2.at(i) - '0';
        
        int sum = (firstBit ^ secondBit ^ carry) + '0';
        ret = static_cast<char>(sum) + ret;
        
        carry = (firstBit & secondBit) | (firstBit & carry) | (secondBit & carry);
    }
    if (carry)
        ret = '1' + ret;
    return ret;
}
 
long int Karatsuba(string s1, string s2)
{
    size_t len = equalizeLength(s1, s2);
    
    // base case
    if (len == 0) return 0;
    if (len == 1) return (s1[0] - '0') * (s2[0] - '0');
    
    size_t floor = len / 2;
    size_t ceil = len - floor;
    string a = s1.substr(0, floor);
    string b = s1.substr(floor, ceil);
    string c = s2.substr(0, floor);
    string d = s2.substr(floor, ceil);
 
    long int p1 = Karatsuba(a, c);
    long int p2 = Karatsuba(b, d);
    long int p3 = Karatsuba(strAddition(a, b), strAddition(c, d));
    return (1<<(2 * ceil)) * p1 + (1<<(ceil)) * (p3 - p1 - p2) + p2;
}
 
int main() {
    string s1,s2;
    cin>>s1>>s2;
    cout <<Karatsuba(s1, s2) << endl;
    return 0;
}
4.1 上述程序实现大整数加法
A.正确
B.错误

4.2 上述程序的算法复杂度大于 （其中n为max(s1.length(),s2.length())）
A.正确
B.错误

4.3 当输入111 011时程序输出为（）
A.10
B.4
C.21
D.2

4.4 当输入10101 101010时程序输出为（）
A.441
B.882
C.1764
D.220

三、完善程序(每题15分，共计30分)
1.（链表反转）单向链表反转是一道经典算法问题，比如有一个链表是这样的，1->2->3->4->5，反转后成为 5->4->3->2->1。现给定如下链表节点的定义：
struct LinkNode{
    int value;
    LinkNode* next;};

非递归实现：
LinkNode* Reverse(LinkNode* header){
    if (header == NULL || header->next == NULL){
        return header;
    }
    
    LinkNode* pre = header, *cur = header->next;
    pre->next = NULL;
    while(cur != NULL)
    {
        LinkNode* next = ____1____;
        ___2____ = pre;
        pre = cur;
        cur = next;
    }
    return pre;}

递归实现：
LinkNode * Reverse(LinkNode * head){
    if (head == NULL || head->next == NULL){
        return head;
    }

    LinkNode* pre = header, *cur = header->next;
    LinkNode * newhead = ___3____;    
    ___4_____ = head;    
    head->next = ___5____;            
    return newhead;
}
1.1    上述程序___1___中应该填写（）
A.pre-> next
B.cur-> next
C.header-> next
D.NULL

1.2上述程序___2___中应该填写（）
A.pre-> next
B.cur-> next
C.header-> next
D.NULL

1.3上述程序___3___中应该填写（）
A.ReverseList(head)
B.ReverseList(pre)
C.ReverseList(cur)
D.ReverseList(head->next)


1.4上述程序___4___中应该填写（）
A.pre-> next->next
B.cur-> next->next
C.header-> next->next
D.NULL

1.5上述程序___5___中应该填写（）
A.pre-> next
B.cur-> next
C.header-> next
D.NULL

2.(最小环问题)给定一张无向图，求图中一个至少包含 3 个点的环，环上的节点不重复，并且环上的边的长度之和最小。该问题称为无向图的最小环问题。在本题中，你需要输出最小环的方案，若最小环不唯一，输出任意一个均可。若无解，输出 No solution.
图的节点数不超过 100100。
输入：
第一行两个正整数 n,m 表示点数和边数。
接下来 m 行，每行三个正整数 x,y,z，表示节点 x,y之间有一条长度为 z 的边。
输出：
一个最小环的方案：按环上顺序输出最小环上的点。若最小环不唯一，输出任意一个均可。若无解，输出 No solution.
#include <bits/stdc++.h>
#define MAXN 105
#define INF 0x3f3f3f3f
using namespace std;
inline int read(){
    int x=0,f=1;
    char ch=getchar();
    while (ch<'0'||ch>'9'){
        if (ch=='-') f=-1;
        ch=getchar();
    }
    while (ch>='0'&&ch<='9'){
        x=(x<<3)+(x<<1)+(ch^'0');
        ch=getchar();
    }
return x*f;}
static int stk[MAXN],top;
static int pos[MAXN][MAXN];//表示i~j的中点节点
#define Push(x) stk[++top]=(x);
void GetAns(int i,int j){
    if (pos[i][j]==0) return ;
    GetAns(i,____1____);
    Push(pos[i][j]);
    GetAns(pos[i][j],____2____);}
static int G[MAXN][MAXN],D[MAXN][MAXN];
int main(){
    int n=read(),m=read();
    memset(G,0x3f,sizeof(G));
    memset(D,0x3f,sizeof(D));
    for (register int i=1;i<=m;++i){
        int u=read(),v=read();
        D[v][u]=D[u][v]=G[u][v]=G[v][u]=min(G[u][v],read());
    }
    int ans=INF;
    for (register int k=1;k<=n;++k){
        for (register int i=1;i<k;++i){
            for (register int j=i+1;j<k;++j){
                if (D[i][j]==INF||G[j][k]==INF||G[k][i]==INF) continue;
                if (D[i][j]+G[j][k]+G[k][i]<ans){
                    ans=_____3_____;
                    top=0;Push(i);GetAns(i,j);Push(j);Push(k);
                }
            }
        }
        for (register int i=1;i<=n;++i){
            for (register int j=1;j<=n;++j){
                if (_____4_____){
                    D[i][j]=D[i][k]+D[k][j];
                    pos[i][j]=k;
                }
            }
        }
    }
    if (ans==INF) return puts("No solution."),0;
    for (register int i=1;i<=top;++i) printf("%d ",_____5____);}
1.1上述程序___1___中应该填写（）
A.j
B.pos[i][j]
C.i
D.pos[j][i]

1.2上述程序___2___中应该填写（）
A.j
B.pos[i][j]
C.i
D.pos[j][i]

1.3上述程序___3___中应该填写（）
A.D[i][j]+G[k][j]+G[i][k]
B.D[i][j]+G[j][k]+G[k][i]
C.D[i][k]+G[k][j]+G[i][j]
D.D[i][j]+G[j][i]+G[i][k]

1.4上述程序___4___中应该填写（）
A.D[k][j]>D[i][k]+D[k][j]
B.D[i][j]>D[i][k]+D[k][j]
C.D[i][j]<D[i][k]+D[k][j]
D.D[i][k]>D[i][k]+D[k][j]

1.5上述程序___5___中应该填写（）
A.pos[i][i]
B.stk[i]
C.pos[1][i]
D.pos[i][1]


 

PUBG___
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
前缀（波兰）、中缀、后缀（逆波兰）表达式
wardo_l的博客
03-11 1383
前缀、中缀、后缀表达式是对表达式的不同记法，其区别在于运算符相对于操作数的位置不同，前缀表达式的运算符位于操作数之前，中缀和后缀同理。 前缀表达式（波兰表达式） 前缀表达式又称波兰式，前缀表达式的运算符位于操作数之前。举例说明(3+4)*5-6对应的前缀表达式就是-*+3456。 前缀表达式的计算机求值：从右往左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶两个数，同运算符对它们做相应的计算（栈顶元素和次顶元素） ...
0715学习日志：算法之逆波兰表达式
opoqou的博客
07-15 119
栈的三种表达式分别是：前缀、中缀和后缀。
CSP-J/S初赛选择题模拟及解析
weixin_68261415的博客
03-28 7828
2、4、8、8组成。每种有A(4,4)/A(2,2)=4×3=12(种)共有12×6=72种.(2)4个不同的数构成，只有1、2、4、8组成,有A(4,4)=4×3×2×1=24(种)(3)2个重复的数字构成，只有1、1、8、8,有C(4,2)=6(种)所以,共有72+24+6=102(种)+(n-2)+(n-1)+n=1+(n+1)*n/2。结果表明，90%的狒狒有进食，其中吃香蕉的狒狒是吃香肠的狒狒数量的3倍，而两种食物都吃的狒狒是只吃香肠的狒狒数量的2/3，则未进食的狒狒是只吃香蕉的狒狒数量的（C）
4~20mA电流输出芯片XTR111完整电路
热门推荐
gflytu的专栏
12-28 2万+
在工控或者和工控相关的行业，一定会遇到需要输出4~20mA电流的时候。而XTR111是应用最广泛的电流输出芯片。 最简单简陋的电流输出电路，是用“三级管+放大器”构成的。如下图所示： 这个电路很简单，你可以试着搭一下，J1是电流输出口，你可以在J1上接个LED灯，随着“电压输入”的变化，LED灯的亮度就会变化，这说明电流发生了变化。 “三极管+放大器”组成
3.23来之即战
w_9898的博客
03-24 3263
1.以下不属于 TCP 拥塞控制方法的是（） A、 慢启动 B、 拥塞避免加法增大 C、 慢启动阈值 ssthresh 减半 D、 慢重传 TCP 拥塞控制方法共有四种：慢启动，拥塞避免，快重传，快恢复 2.关于udp协议，正确的是（） A、 udp需要三次握手，但不需要建立连接 B、 2500B的udp包能够一次穿透以太网 C、 DNS、NFS和SNMP使用的是UDP D、 UDP和TCP一样都会出现粘包问题 只有TCP有粘包现象,UDP永远不会粘包 3.哪个不是进程之间的通.
Test
xurenyi1980的博客
07-26 150
program main implicit none integer::a a=10 write(*,*)a end============ template <typename T>class Blob{ public: typedef T value_type; typedef typename std::vector<T>::size_type size_type; Blob(); Blob(
Googletest 源码
03-14
Googletest 是一个广泛使用的 C++ 测试框架，它为开发者提供了编写单元测试和集成测试的强大工具。这个源码包含 Googletest 的核心组件，使得我们可以深入了解其内部实现，学习如何构建高效的测试框架。 Googletest...
test113123213123
06-18
test113123213123test113123213123test113123213123test113123213123test113123213123test113123213123test113123213123test113123213123test113123213123test113123213123test113123213123test113123213123test...
test1111111111111111111111
最新发布
06-26
test1111111111111111111111
2019CSP-S A卷初赛真题及答案.docx
10-20
2019CSP-S A卷初赛真题及答案2019CSP-S A卷初赛真题及答案2019CSP-S A卷初赛真题及答案
test11111111111111111111
06-26
test333333333333333333333333333
test111111111111111111111111111111111111
06-26
test111111111111111111111111111111111111
test111111111111111111
06-03
test111111111111111111
test123123123123123
05-27
test123123123123123
【高效复习】C语言历年期末试题及历年考研复试题C语言（UESTC）
lyly1995的博客
03-04 9576
2008年—2009年度 填空题 1、在c语言中，以_______开头的字符称为转义字符。 2、在C语言中，没有明确指明函数类型的，自动按______处理。 3、函数原型可以简单的由函数的_____，加上其后的一个“；”构成。 选择题 1、有如下程序： #include&amp;amp;amp;amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;amp;amp;amp;gt; int main(){ char ch1=‘A’,ch2=‘a’; printf(
Cocos Creator使用TypeScript开发，如何定义全局函数和全局变量
zhsafe的博客
08-15 9667
我也是最近才使用ts开发，翻阅cocos论坛资料，不是很明白（哈哈，原谅我，我这人比较笨），那么开始正题： 1.在assets目录下创建一个Global.ts的文件（名字随意），如图： 2.定义全局变量和函数，如图： ps：不要想我这样用，我只是为了测试，测试，测试！！！ 3.再创建一个global.d.ts(名字随意)的文件，根据官方所说，最好不要放在assets目录下，如图： 4.我的文...
CSP-J初赛模拟试题及答案
weixin_68261415的博客
04-06 5823
(1)判断题16. 输入的n等于1001时，程序不会发生下标越界。（X）17. 输入的a[i]必须全为正整数，否则程序将陷入死循环。（X）18. 当输入”5 2 11 9 16 10”时，输出为”3 4 3 17 5”。（X）19. 当输入为”1 511998“时，输出为”18”。（√）20. 将源代码中g函数的定义（13-16行）移到main函数的后面，程序可以正常编译运行。（X）单选题21. 当输入为”2 -65536 2147483647”时，输出为（B）。(2)判断题。
前缀、中缀、后缀表达式及其求值
aibaiwu6038的博客
02-26 509
它们都是对表达式的记法，因此也被称为前缀记法、中缀记法和后缀记法。它们之间的区别在于运算符相对与操作数的位置不同：前缀表达式的运算符位于与其相关的操作数之前；中缀和后缀同理。 比如： (4 + 5) × 6- 7 就是中缀表达式 - × + 4567 前缀表达式 45 + 6×7 - 后缀表达式 中缀表达式（中缀记法） 中缀表达式是一种通用的算术或逻辑公式表示方法，操作...
C++Test安装与使用指南
"C++Test是一款专业的C++测试软件，用于进行静态代码分析和单元测试。这份资料提供了关于C++Test的安装、License配置以及如何使用的一些基础教程。" C++Test是专为C++开发者设计的一款强大的测试工具，它支持静态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值