[N诺] 浙江大学历年机试题解

最新推荐文章于 2024-08-02 20:41:30 发布
最新推荐文章于 2024-08-02 20:41:30 发布
阅读量1k 收藏 11
点赞数 1
分类专栏： C语言 文章标签： c++ 算法 蓝桥杯 leetcode c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tangchujiang/article/details/126898916
版权

1、统计字符

 统计一个给定字符串中指定的字符出现的次数。

测试输入包含若干测试用例，每个测试用例包含2行，第1行为一个长度不超过5的字符串，第2行为一个长度不超过80的字符串。注意这里的字符串包含空格，即空格也可能是要求被统计的字符之一。当读到'#'时输入结束，相应的结果不要输出。
#include<bits/stdc++.h>
using namespace std;

int main()
{
	string c;
    string n;
    while(c[0] != '#'){
        getline(cin,c);
        getline(cin,n);
        int cnt = 0;
        int j = 0;
        for(int i=0;i<c.length();i++){
            for(j=0;j<n.length();j++){
                if(c[i]==n[j])
                    cnt++;
            }
            if(cnt!=0){
                cout << c[i] << " " << cnt << endl;
                cnt = 0;
            }
        }
    }
}

2、畅通工程

省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。经过调查评估，得到的统计表中列出了有可能建设公路的若干条道路的成本。现请你编写程序，计算出全省畅通需要的最低成本。

测试输入包含若干测试用例。每个测试用例的第1行给出评估的道路条数 N、村庄数目M (N, M < =100 )；随后的 N 行对应村庄间道路的成本，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间道路的成本（也是正整数）。为简单起见，村庄从1到M编号。当N为0时，全部输入结束，相应的结果不要输出。

最小生成树问题

#include<bits/stdc++.h>
using namespace std;

int n,m;
const int max_n = 100;

struct node{
    int b,e,w;
}edges[max_n];

bool cmp(node n1,node n2){
    return n1.w<n2.w;
}

int S[max_n]; // 并查集
int find_root(int x){
    while(S[x]>0){
        x = S[x];
    }
    return x;
}

int kruskal()
{
    sort(edges,edges+n,cmp);
    
    int sum = 0; // 最小生成树的权值
    
    for(int i = 0;i<n;i++){
        // 最小边
        node now = edges[i];
        // 若不成环可以加入
        int fb = find_root(now.b);
        int fe = find_root(now.e);
        if(fb!=fe){
            S[fb]=fe;
            sum = sum+now.w;
            m--;
        }
    }
    if(m==1)
        return sum;
    else
        return -1;
}

int main(){
    while(cin>>n>>m){
        if(n==0) break; // 结束条件
        memset(S,0,sizeof(S)); // 全初始化为-1或0
        for(int i=0;i<n;i++){
            cin>>edges[i].b>>edges[i].e>>edges[i].w;
        }
        int ans = kruskal();
        if(ans==-1){
            cout<<"?"<<endl;
        }else cout << ans <<endl;
    }
}

3、畅通工程2

某省调查城镇交通状况，得到现有城镇道路统计表，表中列出了每条道路直接连通的城镇。省政府“畅通工程”的目标是使全省任何两个城镇间都可以实现交通（但不一定有直接的道路相连，只要互相间接通过道路可达即可）。问最少还需要建设多少条道路？

测试输入包含若干测试用例。每个测试用例的第1行给出两个正整数，分别是城镇数目N ( < 1000 )和道路数目M；随后的M行对应M条道路，每行给出一对正整数，分别是该条道路直接连通的两个城镇的编号。为简单起见，城镇从1到N编号。 
    注意:两个城市之间可以有多条道路相通,也就是说
    3 3
    1 2
    1 2
    2 1
    这种输入也是合法的
    当N为0时，输入结束，该用例不被处理。

并查集的应用

#include<bits/stdc++.h>
using namespace std;

int n,m;
const int max_n = 1000;

int S[max_n];

int find_root(int x){
    while(S[x]>0){
        x = S[x];
    }
    return x;
}

int main(){
    while(cin>>n>>m) {
        if (n == 0) break;
        memset(S, 0, sizeof S);
        int sum = 0;
        for(int i =0;i<m;i++){
            int x,y;
            cin >> x >> y;
            int fx = find_root(x);
            int fy = find_root(y);
            if(fx!=fy){
                S[fx] = fy;
                sum++;
            }
        }
        cout << n-sum-1 << endl;
    }
}

4.继续畅通工程

省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。现得到城镇道路统计表，表中列出了任意两城镇间修建道路的费用，以及该道路是否已经修通的状态。现请你编写程序，计算出全省畅通需要的最低成本。

测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( 1< N < 100 )；随后的 N(N-1)/2 行对应村庄间道路的成本及修建状态，每行给4个正整数，分别是两个村庄的编号（从1编号到N），此两村庄间道路的成本，以及修建状态：1表示已建，0表示未建。

当N为0时输入结束。

#include<bits/stdc++.h>
using namespace std;

const int max_n=100;
int n;
struct node{
    int u,v,w;
    int flag;
}edges[max_n];

int cmp(node n1, node n2){
    return n1.w < n2.w;
}

int S[max_n];
int find_root(int x){
    while(S[x]>0){
        x = S[x];
    }
    return x;
}

int kruskal(int m){
    sort(edges,edges+m,cmp);
    int sum = 0;
    int total = 0;
    for(int i=0;i<m;i++){
        node now = edges[i];
        int fa = find_root(now.u);
        int fb = find_root(now.v);
        if(total == n-1){
            break;
        }
        if(fa!=fb){
            sum = sum + now.w;
            S[fa] = fb;
            total++;
        }
    }
    return sum;
}

int main(){
    while(cin>>n){
        if(n==0) break;
        memset(S,-1,sizeof(S));
        int m = n*(n-1)/2;
        for(int i=0;i<m;i++){
            cin>>edges[i].u>>edges[i].v>>edges[i].w>>edges[i].flag;
            if(edges[i].flag==1) edges[i].w=0;
        }
        int ret = kruskal(m);
        cout << ret << endl;
    }
}

5.二叉搜索树

判断两序列是否为同一二叉搜索树序列

开始一个数n，(1<=n<=20) 表示有n个需要判断，n= 0 的时候输入结束。
接下去一行是一个序列，序列长度小于10，包含(0~9)的数字，没有重复数字，根据这个序列可以构造出一颗二叉搜索树。
接下去的n行有n个序列，每个序列格式跟第一个序列一样，请判断这两个序列是否能组成同一颗二叉搜索树。
#include<bits/stdc++.h>
using namespace std;

typedef struct node{
    char data; // 注意是以字符形式建树
    struct node *lchild,*rchild;
}*BitTree;

vector<char> right_ans,each_ans;
void InsertBitTree(BitTree &T,char x){
    if(T==NULL){
        T = new node;
        T->data = x;
        T->lchild = NULL;
        T->rchild = NULL;
        return; // 递归终止
    }else if(T->data > x){
        InsertBitTree(T->lchild,x);
    }else if(T->data < x){
        InsertBitTree(T->rchild,x);
    }
}

void PreOrderTraverse(BitTree T) {
    if (T == NULL) return;
    each_ans.push_back(T->data);
    PreOrderTraverse(T->lchild);
    PreOrderTraverse(T->rchild);
}

int main(){
    int n;
    string right,each;
    while(cin>>n){
        if(n==0) return 0;
        cin >> right;
        BitTree T = NULL;
        for(int i = 0;i<right.size();i++){
            InsertBitTree(T,right[i]);
        }
        PreOrderTraverse(T);
        for (int i = 0; i < each_ans.size(); ++i) right_ans.push_back(each_ans[i]); // 函数里默认写的是each_ans
        while(n--){
            each_ans = {};
            cin>>each;
            BitTree T = NULL;
            for(int i = 0;i<each.size();i++){
                InsertBitTree(T,each[i]);
            }

            PreOrderTraverse(T);
            int flag = 1;
            for(int i=0;i<each.size();i++){
                if(right_ans[i]!=each_ans[i]){
                    flag = 0;
                    break;
                }
            }
            if(flag==1){
                cout << "YES" << endl;
            }else{
                cout << "NO" << endl;
            }
        }
    }
}

6.统计同成绩学生人数

读入N名学生的成绩，将获得某一给定分数的学生人数输出。

测试输入包含若干测试用例，每个测试用例的格式为


第1行：N
第2行：N名学生的成绩，相邻两数字用一个空格间隔。
第3行：给定分数

当读到N=0时输入结束。其中N不超过1000，成绩分数为（包含）0到100之间的一个整数。
#include<bits/stdc++.h>
using namespace std;

int main(){
	int n;
	while(cin>>n){
		if(n==0) return 0;
		map<int,int> a;
		int grade,aim;
		while(n--){
			cin>>grade;
			a[grade]++;
		}
		cin>>aim;
		cout << a[aim] << endl;
	}
}

7.EXCEL排序

Excel可以对一组纪录按任意指定列排序。现请你编写程序实现类似功能。     对每个测试用例，首先输出1行“Case i:”，其中 i 是测试用例的编号（从1开始）。随后在 N 行中输出按要求排序后的结果，即：当 C=1 时，按学号递增排序；当 C=2时，按姓名的非递减字典序排序；当 C=3 时，按成绩的非递减排序。当若干学生具有相同姓名或者相同成绩时，则按他们的学号递增排序。

测试输入包含若干测试用例。每个测试用例的第1行包含两个整数 N (N<=100000) 和 C，其中 N 是纪录的条数，C 是指定排序的列号。以下有N行，每行包含一条学生纪录。每条学生纪录由学号（6位数字，同组测试中没有重复的学号）、姓名（不超过8位且不包含空格的字符串）、成绩（闭区间[0, 100]内的整数）组成，每个项目间用1个空格隔开。当读到 N=0 时，全部输入结束，相应的结果不要输出。
#include<bits/stdc++.h>
using namespace std;

const int max_N = 100000;
struct student{
    string No;
    string name;
    int grade;
}students[max_N];

bool cmp1(struct student stu1,struct student stu2){
    return stu1.No < stu2.No;
}

bool cmp2(struct student stu1,struct student stu2){
    if(stu1.name == stu2.name){
        return stu1.No < stu2.No;
    }else{
        return stu1.name < stu2.name;
    }
}

bool cmp3(struct student stu1,struct student stu2){
    if(stu1.grade == stu2.grade){
        return stu1.No < stu2.No;
    }else{
        return stu1.grade < stu2.grade;
    }
}

int main(){
    int N,C;
    cin >> N >> C;
    for(int i=0;i<N;i++){
        struct student stu;
        cin >> stu.No >> stu.name >> stu.grade;
        students[i] = stu;
    }
    if(C==1){
        sort(students,students+N,cmp1);
    }else if(C==2){
        sort(students,students+N,cmp2);
    }else if(C==3){
        sort(students,students+N,cmp3);
    }
    cout << "Case:"<<endl;
    for(int i=0;i<N;i++){
        cout << students[i].No << " "<<students[i].name<<" " << students[i].grade<<endl;
    }
}

8.最大连续子序列

给定K个整数的序列{ N1, N2, ..., NK }，其任意连续子序列可表示为{ Ni, Ni+1, ..., Nj }，其中 1 <= i <= j <= K。最大连续子序列是所有连续子序列中元素和最大的一个，例如给定序列{ -2, 11, -4, 13, -5, -2 }，其最大连续子序列为{ 11, -4, 13 }，最大和为20。现在增加一个要求，即还需要输出该子序列的第一个和最后一个元素。

测试输入包含若干测试用例，每个测试用例占2行，第1行给出正整数K( K< 10000 )，第2行给出K个整数，中间用空格分隔。当K为0时，输入结束，该用例不被处理。
#include<bits/stdc++.h>
using namespace std;

const int max_k = 10000;

int dp[max_k],dp_copy[max_k];
int main(){
    int k;
    while(cin>>k){
        int flag = 0; // 是否全为负数
        if(k==0) return 0;
        memset(dp,0,max_k);
        for(int i = 0;i<k;i++){
            cin>>dp[i];
            if(dp[i]>=0){
                flag = 1;
            }
            dp_copy[i] = dp[i];
        }
        if(flag){
            for(int i = 1;i<k;i++){
                dp[i] = max(dp[i-1]+dp[i],dp[i]);
            }
            int max_value =*max_element(dp,dp+k);
            int max_pos = distance(dp,max_element(dp,dp+k));

            int temp = max_value;
            int min_pos = max_pos;
            while(dp_copy[min_pos]!=temp){
                temp = temp - dp_copy[min_pos];
                min_pos--;
            }

            cout << max_value <<" "<<dp_copy[min_pos]<<" "<<dp_copy[max_pos]<<endl;
        }else{
            cout << 0 <<" "<<dp_copy[0]<<" "<<dp_copy[k-1]<<endl;
        }
    }
}

9.最短路径问题

给你n个点，m条无向边，每条边都有长度d和花费p，给你起点s终点t，要求输出起点到终点的最短距离及其花费，如果最短距离有多条路线，则输出花费最少的。

输入n,m，点的编号是1~n,然后是m行，每行4个数 a,b,d,p，表示a和b之间有一条边，且其长度为d，花费为p。最后一行是两个数 s,t;起点s，终点t。n和m为0时输入结束。
(1<n<=1000, 0<m<100000, s != t)

有n个集合（初始有n个点，一个点独自成一个集合），先选出一条最短的边，假设它属于集合u，然后从跟它邻接的边中选出一条最短的且不与集合u中已经存在的边形成回路的边，合并到集合u中，再从非u集合中选出一条与集合u中的边邻接且距离最短的边，加入到集合u中，以此类推。

Dijkstra是用来解决给定起点和重点求路径的问题。

#include<bits/stdc++.h>
using namespace std;

const int MAX_N = 1000;

int visited[MAX_N]; // 是否已经访问过该点

int dist[MAX_N]; // dist[i]起点到i的距离
int cost[MAX_N]; // cost[i]起点到i的花费


struct Edge{
    int to;
    int length;
    int price;
    Edge(int i, int j, int k): to(i), length(j), price(k){}
};

vector<Edge> graph[MAX_N];


struct Point{
    int number;
    int distance;
    Point(int i, int j): number(i), distance(j){}
    bool operator< (const Point& p) const{ // 重定义操作符< 使得Point之间可比
        return distance > p.distance;
    }
};


void Dijkstra(int s, int n){ // s到n的最短路
    dist[s] = 0;
    cost[s] = 0;

    priority_queue<Point> q; // 优先队列
    q.push(Point(s, 0)); // 加入起点 起点到起点距离显然为0

    while(!q.empty()){ // 只要q不空
        int u = q.top().number;  // 队列头
        q.pop();

        if(visited[u] == 1){  // 已经被访问过
            continue;
        }
        visited[u] = 1; // 未被访问过 则标记位访问过

        for(int i=0; i<graph[u].size(); i++){ // 遍历与u邻接的边
            int v = graph[u][i].to;
            int uv_price = graph[u][i].price;
            int uv_len = graph[u][i].length;
            if(dist[u] + uv_len < dist[v] || (dist[u] + uv_len == dist[v] && cost[u] + uv_price < cost[v])){ // 直达距离更短或距离相同但花费更少
                // 更新从起点到v的距离
                dist[v] = dist[u] + uv_len;
                cost[v] = cost[u] + uv_price;
            }
            q.push(Point(v, dist[v])); // 加入v 下次循环找v的邻接...

        }
    }
}



int main(){
    int m, n;
    while(cin>>n>>m){
        if(n == 0 && m==0) break;

        memset(graph, 0, sizeof(graph));
        memset(cost, 0x3f, sizeof(cost)); // 0x3f表示无限大
        memset(dist, 0x3f, sizeof(dist)); // 0x3f表示无限大
        memset(visited, 0, sizeof(visited)); // 都是未访问

        for(int i=0; i<m; i++){
            int from, to, d, c;
            cin>>from>>to>>d>>c;
            graph[from].push_back(Edge(to, d, c));
            graph[to].push_back(Edge(from, d, c));
        }

        int s, t;
        cin>>s>>t;

        Dijkstra(s, n);

        cout<<dist[t]<<" "<<cost[t]<<endl;
    }

    return 0;
}

10.xxx定律

对于一个数n，如果是偶数，就把n砍掉一半；如果是奇数，把n变成 3*n+ 1后砍掉一半，直到该数变为1为止。     请计算需要经过几步才能将n变到1，具体可见样例。

测试包含多个用例，每个用例包含一个整数n,当n为0 时表示输入结束。（1<=n<=10000）
#include<bits/stdc++.h>
using namespace std;

int main(){
    int n;
    while(cin>>n){
        if(n==0) return 0;
        int cnt = 0;
        while(n!=1){
            if(n%2==0){
                n = n/2;
            }else{
                n = (3*n+1)/2;
            }
            cnt++;
        }
        cout << cnt << endl;
    }
}

JKD_wen
关注
  • 1
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2023考研一战浙大计算机专硕总分第15名经验贴
weixin_48686926的博客
03-29 2459
备考浙大经验贴
武汉大学 WOJ STARTER 题解 考研复试 机试
08-22
【武汉大学WOJ STARTER题解】是针对武汉大学在线oj网站acm.whu.edu.cn上"starter"部分的题目解析，主要服务于计算机学院考研复试的机试环节。这一资源集合了众多考生在复习和备考过程中可能会遇到的问题，旨在帮助...
浙江工业大学python试卷_20浙江工业大学计算机专硕考研经验贴
weixin_39775910的博客
11-29 1095
更新于2020.08.05 11:10 长沙：（1）在 “七、问答”中增加条目“王道内容与考纲不符合怎么办？”、“哪些知识点是重点，真题有规律吗？如何做考点考频统计？”、“关于我的数学方法？”、“在其他学长/学姐那买的真题资料包中，带有计网背诵资料，可以跟这份资料吗？”（2）我创建了一个21浙工大计算机考研群 812540748。如果有任何困惑，可在群里提问。我本贴的问答板块就是根据大家私下问我的...
211逆袭浙大-计算机及相关衍生专业保研之路纪实（深度长文，收藏了）
热门推荐
诸神缄默不语的博客
01-03 1万+
面试过N个院校，最后上岸浙江大学软件学院
CSP-J2 CSP-S2 复赛 第2轮 比赛技巧-做题策略与时间分配、容易犯错误汇总 NOI Linux2.0文件操作等
青少年趣味编程
09-30 1374
CSP-J2 CSP-S2 复赛 第2轮 比赛技巧-做题策略与时间分配、容易犯错误汇总 NOI Linux2.0文件操作等
跨保计算机的同学需要做哪些准备？
Baoyan_cs的博客
10-14 1048
写在前面 虽说计算机十分热门，但对于转计算机专业、跨保计算机专业的同学来说，优势与风险并存。基础知识落后，准备起来艰难耗时，在以后的学习生涯里，可能会遇到一个又一个头疼的问题，很容易击溃同学的心态。很多人都说过，学习计算机，没有兴趣的话，别来。因为硬着头皮去学，是会很痛苦的。不是因为它特别难，而是因为它繁杂、成效慢，需要长效长期去学。 岛主有一些为跨保计算机的同学准备的一些小建议，希望同学们在这场战役中不会无枪无炮。 1. 适合跨保同学投递的院校 对于跨保的同学来说，要投递自己的简历到计算机相关
acm.rar_浙江大学 ACM 题解
09-24
【标题】"acm.rar_浙江大学 ACM 题解" 涵盖的是关于浙江大学在ACM（国际大学生程序设计竞赛）方面的训练资料和解题思路。这些资源通常包括历年的竞赛题目、官方解答以及参赛者们分享的解题策略，旨在帮助学习者提升...
浙江大学 程序设计入门mooc课程第五周题解
01-25
浙江大学mooc课程第五周题解，总共五道题目，包括： 最后一节习题课的三道题：1.求前n项和； 2.求最大公约数 3.求逆序数（保留所有0，如7000输出为0007） 以及课后测验的两道题目： 1.求第n到第m个素数的和 2.用拼音...
浙江大学计算机复试题解和上机题解
06-09
浙江大学计算机复试题解和上机题解是一份珍贵的学习资源，专门为准备参加浙江大学计算机专业复试的学生提供指导。这份资料涵盖了复试的各项科目，旨在帮助考生全面掌握计算机领域的核心知识，并提升解决实际问题的...
浙江大学ACM题解JU_ACM_All_Anwer
09-21
《浙江大学ACM题解JU_ACM_All_Anwer》是一份极为宝贵的资源，它集结了浙江大学在ACM（国际大学生程序设计竞赛）历年来的题目及其解答。这份资料以CHM电子书的形式呈现，方便读者查阅和学习。对于那些对ACM编程竞赛感...
C语言基础——数据类型
2301_78622258的博客
07-29 861
本文主要讲述C语言当中的基本数据类型，以及涉及到的常量，变量的相关知识本文主要介绍了C语言中的数据类型，变量的表示，常量的表示，以及各种变量的取值范围。
C语言——自定义函数向右移动数组中的元素
qq_59990833的博客
08-01 309
C语言——自定义函数向右移动数组中的元素
LeetCode 572.另一棵树的子树 C写法
最新发布
m0_63816268的博客
08-02 102
可以用上的方法，，如果有一轮比较成功就表示root包含subroot。
【C++】输入输出
2401_83948390的博客
08-02 112
在C++中，输入输出操作主要通过标准库中的iostream头文件提供的一系列对象和函数来完成。
C++｜设计模式（八）｜⭐️工厂模式？错！是工厂模式群！
糖炒栗子
08-02 436
首先我们按照与 Employee 类相同的方式来创建所有不同项目对应的基类（父类）Project，在这个类中我们还定义了与项目相关的接口 assignTo ，这个接口可以将某个项目指派给对应账户ID的员工，还是相同的方式我们定义 ITProject 与 UIProject 这两个不同项目的子类，并提供 assignTo 接口的不同实现。
【2024蓝桥杯/C++/B组/传送阵】
m0_73669127的博客
07-30 308
【代码】2024蓝桥杯/C++/B组/传送阵。
第六章 - c语言中的数组-二维数组（下）
百知_zmj的博客
08-02 99
二维数组案例：杨辉三角形。
c语言之函数调用约定
qq_45583706的博客
08-02 370
在C和C++编程中，函数调用约定（Calling Convention）定义了函数参数如何传递、由谁负责清理栈（如果有的话）、以及返回值如何传递等规则。不同的平台和编译器可能采用不同的调用约定。不同的调用约定适用于不同的场景和需求。了解这些调用约定的特点和适用场景有助于编写更高效、更可移植的代码。在选择调用约定时，需要考虑目标平台、编译器、以及与其他代码或库的兼容性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值