北邮2019年机试真题及参考代码

Problem A

题目描述：

输入 32 位的二进制 01 串，输出这个数+1 和+3 后的 32 位二进制串。

输入描述：
先输入 T，表示输入的组数；然后输入 T 行二进制串
输出描述：

输出+1 和+3 后的二进制串

输入样例：

2
00000000000000000000000000000000
00000000000000000000000000000001

输出样例：

00000000000000000000000000000001
00000000000000000000000000000011
00000000000000000000000000000010
00000000000000000000000000000100

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

int c[33];

void Add(int a[], int b[]){     //实现二进制加法
    memset(c,0,sizeof(c));
    int carry = 0;
    for(int i = 0; i < 32; i++){
        switch(a[i] + b[i] + carry){
        case 0:
            c[i] = 0;
            carry = 0;
            break;
        case 1:
            c[i] = 1;
            carry = 0;
            break;
        case 2:
            c[i] = 0;
            carry = 1;
            break;
        case 3:
            c[i] = 1;
            carry = 1;
            break;
        }
    }
}

void print(){
    for(int i = 31; i >= 0; i--){
        cout<<c[i];
    }
    cout<<endl;
}

int main(){
    int a, a2[33],b[32];
    while(cin >> a){
        memset(a2,0,sizeof(a2));
        memset(b,0,sizeof(b));
        for(int i = 0; i < 32; i++){
            if(a != 0){
                a2[i] = a%10;
                a /= 10;
            }
        }
        b[0] = 1;
        Add(a2,b);
        print();
        b[1] = 1;
        Add(a2,b);
        print();
    }
    return 0;
}

Problem B

题目描述：
根据输入父节点的两个子节点，根据输入构建一棵树，然后输入两个节点，寻找两个节点之间的距离。

输入描述：
先输入 T，表示输入的组数，再输入 n,m，n 表示父节点个数(n>=1),其中 1 号节点默认为根节点，m 表示查询的组数。

输出描述：
每组查询的两个点之间的距离。

输入样例：

5 2
2 3
4 5
6 -1
-1 -1
7 -1
6 7
2 3

输出样例：

5
2

代码

#include<iostream>
#include<cstdio>
#include<queue>
using namespace std;

struct Node{
    Node *left;
    Node *right;
    int c;
}Tree[110];

int loc;
bool flag;

Node* creat(int a){
    Tree[loc].left = Tree[loc].right = NULL;
    Tree[loc].c = a;
    return &Tree[loc++];
}

int lowestCommonAncestor(Node* root, int p, int q) {
    if (root == NULL){
        return 0;
    }else if(root->c == p|| root->c == q){
        return 1;
    }
    int left = lowestCommonAncestor(root->left, p, q);
    int right = lowestCommonAncestor(root->right,p,q);
    if (left!=0 && right!=0) {  // 左右节点都 != 0 代表当前节点是最小公共祖先，flag 赋值 true
        flag = true;
        return left + right;       //两点最短路径就是p、q 到最小公共祖先的路径之和
    }else if(!flag){                //flag = false 代表还没找到，向上返回时路径长度+1
        if(left == 0 && right != 0)
            return right +1;
        else if(left != 0 && right == 0)
            return left + 1;
        return 0;
    }else if(flag){         //flag = true 证明已经找到了，直接向根节点返回最短路径长度
        if(left != 0)
            return left;
        else
            return right;
    }
}

int main(){
    queue<Node *> Tqueue;
    int n, m, left, right, a, b;
    Node *T = creat(1);
    Tqueue.push(T);
    while(cin>>n>>m){
        while(n--){     //层次遍历输入二叉树
            cin>>left>>right;
            Node *l = creat(left), *r = creat(right);
            Tqueue.push(l);
            Tqueue.push(r);
            Node* temp = Tqueue.front();
            Tqueue.pop();
            temp->left = l;
            temp->right = r;
        }
        while(m--){
            flag = false;
            cin>>a>>b;
            cout<<lowestCommonAncestor(T,a,b)<<endl;
        }
    }
    return 0;
}

注：题目来自网络上的回忆版真题，代码是自己所写。另外因为题目在oj上已经找不到了，所以本文的代码也不能保证AC，只是提供一种思路，笔者会陆续分享近些年北邮机试真题的代码，欢迎大家批评指正。