2019北邮计算机机试

注意：所有代码均是根据题目描述进行了本地测试，没有在北邮oj上测试，不保证一定能AC。

点击链接查看历年机试题目汇总。

A二进制

题目描述

32位二进制数X，对其进行X+1,X+3 操作，并输出。注意不能忽略前导0

输入
第一行，一个整数T,代表测试数据组数。
接着T行，输入32为二进制数

输出
对每组测试数据，输出两行，第一行为X+1,第二行为X+3.

样例输入

2
00000000000000000000000000000000
00000000000000000000000000000001

样例输出

00000000000000000000000000000001
00000000000000000000000000000011
00000000000000000000000000000010
00000000000000000000000000000100

解析

二进制加1就是对最低位加1，然后处理进位。
二进制加3就是在加1的基础上再加2，即对倒数第二位加1，处理进位。  

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

void add(int begin,int end,char a[]) 
{
	for(int i=begin;i>=0;i--)
	{
		if(a[i]=='0') 
			{
				a[i]='1';
				break; 
			}
			else
			{
				a[i]='0';
			}
	}
	cout<<a<<endl;
}
int main()
{
	int T;
	cin>>T;
	while(T--)
	{
		char a[32];
		cin>>a;
		add(31,0,a);
		add(30,0,a); 
	}
	return 0;
}

B 二叉树

题目描述

对二叉树，计算任意两个结点的最短路径长度。

输入
第一行输入测试数据组数T
第二行输入n,m 。n代表结点的个数，m代表要查询的数据组数
接下来n行，每行输入两个数，代表1~n结点的孩子结点，如果没有孩子结点则输入-1.根节点为1.
接下来m行，每行输入两个数，代表要查询的两个结点

输出
每组测试数据输出m行，代表查询的两个结点之间的最短路径长度

样例输入

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

样例输出

2
4
2
4

解析

用一个数组记录节点的父节点，求出两节点的深度，
先统一到相同深度，再同时向上走，直到相同。

#include <iostream>
using namespace std;
int depth(int t[],int v)
{
	if(t[v]==0) return 0;
	else return depth(t,t[v])+1;
}
int main()
{
	int T;
	cin>>T;
	while(T--)
		{
			int n,m,f[100],d[100];
			f[1]=0;
			cin>>n>>m;
			int x,y;
			for(int i=1; i<=n; i++)
				{
					cin>>x>>y;
					if(x!=-1) f[x]=i;
					if(y!=-1) f[y]=i;
					d[x]=depth(f,x);
					d[y]=depth(f,y);
				}
			while(m--)
				{
					cin>>x>>y;
					int count=0;
					int d1=d[x],d2=d[y];
					while(d1!=d2)
						{
							count++;
							if(d1>d2)
								{
									d1--;
									x=f[x];
								}
							else
								{
									d2--;
									y=f[y];
								}
						}
					while(x!=y)
						{
							count+=2;
							x=f[x];
							y=f[y];
						}
					cout<<count<<endl;
				}
		}
	return 0;
}

C 中序遍历树

题目描述

在白天和黑夜要从城市1到城市n，黑夜会关掉若干条线路，分别寻找城市1到城市n的在白天和黑夜的最短路径。

输入
第一行数据组数T
第二行输入n,m,k. n代表城市数，m代表路径数，k代表夜间关闭的路径数
接下来m行，每行输入三个数x,y，val，代表城市x和城市y之间连通的距离为val
最后一行k个数，代表晚上关闭的线路序号（线路序号指的是1~m）
感谢补充：不保证无重边，这是考试时，后来补发的公告,所以这题a出的人很少也有这个原因

输出
每组数据输出两行，分别代表白天和黑夜，城市1到n的最短路径

样例输入

1
4 4 1
1 2 1
2 3 1
3 4 1
1 4 1
4

样例输出

1
3

解析

这道题主要是要考虑有重边的情况，先用一个vector数组保存路径及边，
然后再分白天和黑夜讨论。 

#include <iostream>
#include <vector>
#include <algorithm>
#define INF 0x3fffffff
using namespace std;
int n,m,k;
int G[1001][1001];
struct edge
{
	int val;
	int d;
	int f;
	edge(int from,int to,int v)
	{
		f=from;
		d=to;
		val=v;
	}
};
int floyd()
{
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			for(int k=1;k<=n;k++)
			{
				if(G[i][k]!=INF&&G[k][j]!=INF&&G[i][k]+G[k][j]<G[i][j])
				G[i][j]=G[i][k]+G[k][j];
			}
		}
	}
	return G[1][n];
}
/*
//dijkstra算法 
int d[1001],vis[1001];
int dijkstra()
{
	fill(d,d+1001,INF);
	fill(vis,vis+1001,0);
	d[1]=0;
	for(int i=0;i<n;i++)
	{
		int u=-1,min=INF;
		for(int j=1;j<=n;j++)
		{
			if(!vis[j]&&d[j]<min)
			{
				u=j;
				min=d[j];
			}
		}
		if(u!=-1) 
		{
			vis[u]=1;
		}
		for(int j=1;j<=n;j++)
		{
			if(!vis[j]&&G[u][j]!=INF&&d[u]+G[u][j]<d[j])
			d[j]=G[u][j]+d[u];
		}
	}
	return d[n];
}
*/
vector<edge> E;
int main()
{
	int T;
	cin>>T;
	while(T--)
	{
		E.clear();
		fill(G[0],G[0]+1001*1001,INF);
		int x,y,val,close[1001]={0};
		cin>>n>>m>>k;
		for(int i=1;i<=m;i++)
		{
			cin>>x>>y>>val;
			E.push_back(edge(x,y,val));
		}
		for(int i=0;i<k;i++) 
		{
			int t;
			cin>>t;
			close[t]=1; //哈希 
		}
		for(unsigned int i=0;i<E.size();i++)
		{
				G[E[i].f][E[i].d]=G[E[i].d][E[i].f]=min(E[i].val,G[E[i].f][E[i].d]);	
		}
		cout<<floyd()<<endl;
		//cout<<dijkstra()<<endl;
		fill(G[0],G[0]+1001*1001,INF);
		//黑夜 
		for(unsigned int i=0;i<E.size();i++)
		{
			if(close[i+1]==0)
			{
				G[E[i].f][E[i].d]=G[E[i].d][E[i].f]=min(E[i].val,G[E[i].f][E[i].d]);
			}
		}
		cout<<floyd()<<endl; 
		//cout<<dijkstra()<<endl;
	}
	return 0;
}

D 

据说这道题现场没有人做出来，很难，在网上我连题目都没找到。