2019 北邮计算机学院机试附AC代码以及结果统计

最新推荐文章于 2024-06-20 11:34:54 发布

微扬

最新推荐文章于 2024-06-20 11:34:54 发布

阅读量2k

点赞数 5

文章标签：机试北邮复试北邮计算机学院

本文链接：https://blog.csdn.net/qq_36159351/article/details/88966702

版权

今年计院题目可能比网研难度大一些，没有AK，13人3A，57人2A，98人1A，24人0A

给大家趁热回忆一下题目.

以下题目为回忆版，有些数据细节记不起来了

Problem A 二进制

时间限制 1000 ms 内存限制 65536 KB

题目描述

给出一个32位二进制数X，不忽略前导零，计算X+1和X+3。

输入格式

第一行为测试数据的组数T。
每组数据包括一行：二进制串X

输出格式

每组数据输出两行，分别为X + 1 和X + 3

输入样例

2
00000000000000000000000000000000
00000000000000000000000000000001

输出样例

00000000000000000000000000000001
00000000000000000000000000000011
00000000000000000000000000000010
00000000000000000000000000000100

AC代码：

#include <bits/stdc++.h>

using namespace std;

#define LL long long
#define FF(i,a,b) for(int i = a;i<b;i++)
#define FF_(i,a,b) for(int i = a;i<=b;i++)

int main()
{
    int T;
    cin >> T;
    while(T--){
        string s;
        cin >> s;
        int c = 1;
        for(int i = s.size() - 1; i >=0 ; i--){
            int num = s[i] - '0';
            int tmp = num + c;
            s[i] = tmp % 2 +'0';
            c = tmp /2;
        }
        cout << s << endl;
        c = 2;
        for(int i = s.size() - 1; i >=0 ; i--){
            int num = s[i] - '0';
            int tmp = num + c;
            s[i] = tmp % 2 + '0';
            c = tmp / 2;
        }
        cout << s << endl;
    }
    return 0;
}

Problem B 二叉树

时间限制 1000 ms 内存限制 65536 KB

题目描述

给出一棵二叉树，求两个节点之间的距离。

输入格式

第一行为数据组数T
每组数据第一行两个整数n，m。分别代表二叉树节点的个数以及查询次数。

接下来n行，每行两个整数p，q，其中第K（1<=K<=n）行代表结点K的左右子结点分别为p，q。若无子节点则用-1表示。根节点编号为1。

接下来m行，每行两个整数a，b(1<=a,b<=n)，求出从结点a到结点b的距离。

输出格式

每组数据输出m行，对应m次查询的结果。

输入样例

输出样例

思路，直接用图的形式存储，然后BFS

AC代码：

#include <bits/stdc++.h>

using namespace std;

#define LL long long
#define FF(i,a,b) for(int i = a;i<b;i++)
#define FF_(i,a,b) for(int i = a;i<=b;i++)

vector<vector<int> > t(510);//每条边权值都是1，直接用二维数组存储。

int bfs(int a,int b){//BFS 从a点到b点
    vector<bool> vis(510,false);
    queue<int> q;
    q.push(a);
    vis[a] = true;
    int level = 0;
    while(!q.empty()){
        int k = q.size();
        FF(i,0,k){
            int tmp = q.front();
            q.pop();
            FF(i,0,t[tmp].size()){
                int cur = t[tmp][i];
                if(cur == b){
                    return level + 1;
                }
                if(vis[cur] == false){
                    vis[cur] = true;
                    q.push(cur);
                }
            }
        }
        level ++;
    }

}

int main()
{
    int T;
    cin >> T;
    while( T--){
        int n,m;
        cin >>n >> m;
        FF_(i,1,n){
            int t1,t2;
            cin >> t1 >>t2;
            if(t1 != -1){
                t[t1].push_back(i);
                t[i].push_back(t1);
            }
            if(t2 != -1){
                t[t2].push_back(i);
                t[i].push_back(t2);
            }
        }
        FF(i,0,m){
            int a,b;
            cin >> a >> b;
            cout <<bfs(a,b)<<endl;
        }
    }
    return 0;
}

Problem C 城市道路

时间限制 1000 ms 内存限制 65536 KB

题目描述

n个城市之间有若干道路，其中某些道路黑夜需要关闭，分别求出城市1到城市n白天和黑夜的最短路径。

输入格式

第一行为数据组数T
对于每组测试数据

第一行三个整数，n,m,k. （1<=n<=50）n表示城市个数，m表示道路个数，k表示黑夜需要关闭的道路个数。

接下来m行，每行三个整数 a，b，c (1<=a,b<=n)，其中第 i 行（1<=i <=m）表示第 i 条道路为从城市a到城市b长度为c（可能存在重复边）。

接下来k行，每行一个整数w，表示黑夜要关闭的道路编号。

输出格式

每组数据输出两行

第一行为白天从城市1到城市n的最短距离

第一行为黑夜从城市1到城市n的最短距离

输入样例

输出样例

1
3

思路：由于本人比较菜，Dijkstra不太会用，还好数据量比较小，直接Floyd

AC代码：

#include <bits/stdc++.h>

using namespace std;

#define LL long long
#define FF(i,a,b) for(int i = a;i<b;i++)
#define FF_(i,a,b) for(int i = a;i<=b;i++)

struct road{
    int left;
    int right;
    int wight;
    bool istrue = false;
};

void floyd(vector<vector<LL> > &g){
    int n = g.size() - 1;
    FF_(k,1,n){
        FF_(i,1,n){
            FF_(j,1,n){
                if(g[i][j] > g[i][k] + g[k][j]){
                    g[i][j] = g[i][k] + g[k][j];
                }
            }
        }
    }
}

int main()
{
    int T;
    cin >> T;
    while(T--){
        int n,m,k;
        cin >> n >> m >> k;
        vector<LL> tmp(n + 1,INT_MAX);//由于把没有路径设置成了INT_MAN，floyd的时候如果是int类型会出错，当时也是因为这个问题卡了好久。
        vector<vector<LL> > g(n + 1,tmp);
        FF_(i,1,n){
            g[i][i] = 0;
        }
        vector<road> rr(m + 1);
        FF_(i,1,m){
            int a,b,c;
            cin >> a >> b >> c;
            rr[i].left = a;
            rr[i].right = b;
            rr[i].wight = c;
        }
        FF_(i,1,m){
            g[rr[i].left][rr[i].right] = rr[i].wight;
            g[rr[i].right][rr[i].left] = rr[i].wight;
        }

        floyd(g);
        cout << g[1][n] << endl;
        vector<vector<LL> > g2(n + 1,tmp);//可能会有重复边，所以不能直接在原图上删边，干脆重新初始化一个新图。
        FF_(i,1,n){
            g2[i][i] = 0;
        }
        FF_(i,1,k){
            int tmp;
            cin >>tmp;
            rr[tmp].istrue = true;
        }
        FF_(i,1,m){
            if(rr[i].istrue == false){
                g2[rr[i].left][rr[i].right] = rr[i].wight;
                g2[rr[i].right][rr[i].left] = rr[i].wight;
            }
        }
        floyd(g2);
        cout << g2[1][n] << endl;
    }
    return 0;
}

第四题没做出来，题干也想不起来了，就到这吧。