2019北航考研机试题解

 

第一场第一题： 

#include
#define MAX 150005
#define MOD 1000000007
typedef long long LL;
//const int INF = 1e9+7;
#define VM 1000010
using namespace std;
#define inf 0.00000001

//2019年第一场的第一题，给定区间[a,b],输出这个区间里最长的连续合数段

int a[1000005];
int count1 = 0;
int maxn = 1, tag = 0;

//判断合数
bool judge(int n)
{
    for (int i = 2; i <= (int)sqrt(n); i++)
        if (n%i == 0)
            if (n != 2)
                return true;
    return false;
}

//把合数存到数组a
void save(int n, int m)
{
    for (int i = n; i <=m; i++)
        if (judge(i))
        {
            a[count1] = i;
            count1++;
        }
}

 void compare(int a[])
{
    int m = 1;
    for (int i = 0; i < count1; i++)
        if (a[i + 1] - a[i] == 1)
            m++;
        else
        {
            if (m > maxn)
            {
                maxn = m;
                tag = i;//连续合数的最后一个

            }
            m = 1;
        }
}

//主函数
int main()
{
    int n, m;
    scanf("%d %d", &n, &m);
    save(n, m);
    compare(a);
    for (int i = tag - maxn+1; i <= tag; i++)
    {
        printf("%d ", a[i]);
    }
    return 0;

}

第二场第一题：

区间素数等差数列

#include
#define MAX 150005
#define MOD 1000000007
typedef long long LL;
//const int INF = 1e9+7;
#define VM 1000010
using namespace std;
#define inf 0.00000001

int sushu(int n){
    for(int i = 2;i*i<=n;i++){
        if(n%i==0){
            return 0;
            break;
        }
    }
    return 1;
}

int main()
{
    int a,b,arr[100000];
    int n;
    //scanf("%d",&n);
    //if(sushu(n)==1)printf("1\n");
    scanf("%d%d",&a,&b);
    int k = 0;
    for(int i = a;i2){
            for(int m=0;m

第一场第二题：给出几种网络设备（主机、交换机、路由器等），交换机最多八个接口，组成树形网络拓扑，要求给一台主机的编号，求距离它最近的交换机的编号（或者可能是输出路径），如果有多台最近交换机，则输出先序遍历最前边的那个。

这个题没数据，自己设计了一个。思路就是建八叉树，再相应建一个无向图，先把交换机节点按先序顺序先后存一下，然后给一个出发点，以每个交换机节点为出发点bfs无向图求到出发点的最短路（边权视为1，这里懒得用什么高端最短路算法了），顺便存了下路径（第二场第二题其实也可以bfs,思路差不多）。找一个最小的最短路就行。

#include
#define MAX 150005
#define MOD 1000000007
typedef long long LL;
//const int INF = 1e9+7;
#define VM 1000010
using namespace std;
#define inf 10000007
/*
struct node{
    char c;
    int num;
    bool operator < (const node &a)const
    {
        if(num!=a.num)
            return num < a.num;
        return c>a.c;
    }
}nd[1005];
template string toString(const T& t){
    ostringstream oss;  //创建一个格式化输出流
    oss< dian;
void qxbl(int root){
    if(root!=-1){
        //cout< g[1005];//建无向图
int dis[1005];
int path[1005];//存储路径用,需要输出路径就反响找一下即可
int bfs(int st,int ed){
    queue qu;
    int i;
    for(i=0;i<1005;i++)dis[i]=inf;
    dis[st]=0;
    qu.push(st);
    while(!qu.empty()){
        int v=qu.front();
        qu.pop();
        for(i=0;i

第二场第二题：

题目描述：（看的网上学弟的题目描述，很全）一个关于三叉树的题目，小于100的值代表树叶，大于100的值为分支点，建树的过程是水平方向建树，输入格式：

先输入n，代表有n组数据，接下来n行，输入4个数，第一个数代表根节点，接下来分别代表三个子节点，-1代表子节点不存在，输入的顺序按照层次遍历的次序。接下来，要求寻找叶子节点的最短路径，最短路径是指不经过重复的边。输入方式，首先输入一个值m，代表m行，接下来m行输入m个叶子节点和对应的优先级，要求按优先级输出从上次到达的位置到该节点的最短路径，每条路径的最后一个节点要求输出目标叶子节点，最后要求回到根节点。
--------------------- 
作者：sinat_38425013 
来源：CSDN 
原文：https://blog.csdn.net/sinat_38425013/article/details/88749325 

样例：
10
100 101 108 107
101 1 102 2
108 103 104 105
107 17 109 18
102 3 4 5
103 7 8 9
104 10 106 11
105 15 16 -1
109 19 20 21
106 12 13 14
5
8 1
14 3
16 2
5 0
19 4

answer:

100 101 102 5
102 101 100 108 103 8
103 108 105 16
105 108 104 106 14
106 104 108 100 107 109 19
109 107 100

和18年第二题树形态很类似，17年LCA改改其实也可以A这个，主要是换成三叉再加个合并路径。
不过显然bfs写这个题代码量更少（基本和上边那个题一样的写法），不过复杂度就不好说了。。。反正都是小数据量。。
#include
#define MAX 150005
#define MOD 1000000007
typedef long long LL;
//const int INF = 1e9+7;
#define VM 1000010
using namespace std;
#define inf 0.00000001
/*
struct node{
    char c;
    int num;
    bool operator < (const node &a)const
    {
        if(num!=a.num)
            return num < a.num;
        return c>a.c;
    }
}nd[1005];
template string toString(const T& t){
    ostringstream oss;  //创建一个格式化输出流
    oss< path1,path2;
//int len1,len2;
void getpath(int d,int root,vector &path){//求根到目标节点的路径（不包含根）
    if(d==root)return ;//根自己
    if(root>=100){
            //printf("%d\n",root);
        for(int i=0;i<3;i++){
            if(nd[root][i]==d){
                path.push_back(d);//判断是否找到目标节点，若找到直接返回
                return ;
            }
            if(nd[root][i]>=100){
                path.push_back(nd[root][i]);
                getpath(d,nd[root][i],path);
            }
            else continue;
            int len=path.size();
            if(!path.empty()&&!(d==path[path.size()-1]))//防止找到目标节点后仍然有其他节点加入路径
                path.erase(path.begin()+len-1,path.begin()+len);
        }
    }
}
void printshortpath(int root){
    vector anspath;
    int times=0; //记录path1元素的访问次数
    int i,j;
    for(i=0;i::iterator it;
        it = find(path2.begin(),path2.end(),path1[i]);
        if(it!=path2.end()){ //判断path2里含path1的某个节点，即一个LCA
            for(j=path2.size()-1;j>i;j--) //合并路径
                anspath.push_back(path2[j]);
            for(j=i;j=0;i--)//合并路径
                    anspath.push_back(path2[i]);
                anspath.push_back(root);
                for(i=0;i=1;j--)
        cout<