2014北邮网研机试

最新推荐文章于 2020-05-19 16:39:49 发布

Reticent_Man

最新推荐文章于 2020-05-19 16:39:49 发布

阅读量319

点赞数

本文链接：https://blog.csdn.net/reticent_man/article/details/105748350

版权

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

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

A分数加法

题目描述

求2^(-a)+2^(-b)，其中a和b均为正整数，结果请用最简分数表示。
输入格式
第一行为测试数据的组数T（1<=T<=400）。请注意，任意两组测试数据之间是相互独立的。
每组测试数据一行，包含两个整数a和b（2<=a,b<=20）。
输出格式
对于每组测试数据，在一行内输出结果，分子和分母用"/"隔开。

样例输入

2
2 4
3 2

样例输出

5/16
3/8

解析

2^a 2^b 一定可以相互整除
只有当两数相等时需要约分（除以2），两数不等时商一定是偶数，那么分子一定是奇数，不可约分。

#include <iostream>
using namespace std;
int ans1,ans2;
int main()
{
	int n,a,b;
	cin>>n;
	while(n--)
	{
		ans1=1;
		ans2=1;
		cin>>a>>b;
		while(a--) ans1*=2;
		while(b--) ans2*=2;
		if(ans1==ans2) cout<<"1/"<<ans1/2<<endl; 
		else if(ans1%ans2==0) cout<<ans1/ans2+1<<"/"<<ans1<<endl;
		else if(ans2%ans1==0) cout<<ans2/ans1+1<<"/"<<ans2<<endl;
		
		}
	return 0;
}

B 矩阵连乘

题目描述

给定一棵带权二叉树，请判断它是不是一个最小堆。
一棵二叉树是一个最小堆，当且仅当对于树上任意一个节点，它的权值都小于或等于以它为根的子树中的所有权值。
输入格式
输入数据第一行是一个整数T（1<=T<=100），表示测试数据的组数。
对于每组测试数据：
第一行是一个整数N（1<=N<=100），表示树的节点个数。
接下来一行包含N个正整数，第i个整数valuei(1<=valuei<=1000)表示编号i的点的权值。
接下来N-1行，每行两个整数u和v（1<=u，v<=N, u!=v），表示节点u是节点v的父节点。
测试数据保证给定的一定是一棵二叉树，并且节点1是树的根结点。
输出格式
对于每组测试数据，如果给定的树是一个最小堆则输出Yes，否则输出No。

样例输入

3
1
10
3
10 5 3
1 2
1 3
5
1 2 3 4 5
1 3
1 2
2 4
2 5

样例输出

Yes
No
Yes

解析

判断最小堆：每个节点值小于等于其子节点值。

#include <iostream> 
#include <queue>
using namespace std;
struct TreeNode
{
	int val;
	TreeNode* left;
	TreeNode* right;
	/*
    TreeNode(int x): val(x),left(NULL),right(NULL) {
	  } 
    */
}node[101];
int main()
{
	int T;
	cin>>T;
	while(T--)
	{
		int N,x,y;
		int ok=1;
		cin>>N;
		int fa[101];
		for(int i=1;i<=N;i++) cin>>node[i].val;
		for(int i=1;i<=N-1;i++)
		{
			cin>>x>>y;
			if(node[x].val>node[y].val) 
			{
				ok=0;
			}
		}
		if(ok) cout<<"Yes"<<endl;
		else cout<<"No"<<endl;
	}
	return 0;
}

C哈希映射

题目描述

在操作系统中，进程管理是非常重要的工作，每个进程都有唯一的进程标识（PID）。每个进程都可以启动子进程，此时我们称它为其子进程的父进程，除了PID为0的进程之外，每个进程有且只有一个父进程，在这个任务中，你需要实时维护操作系统运行中的三个基本操作：
1.FORK PID1 PID2：标识为PID1的进程启动了一个标识为PID2的子进程。
2.KILL PID：结束标识为PID的进程。请注意，与此同时所有PID的子进程也将同时结束。如果PID是不存在或已经结束的进程，则不做任何操作。
3.QUERY PID：查询标识为PID的进程是否仍然存在。
在初始状态下，系统只开启了PID为0的进程，并且在任何情况下该进程不会结束。
输入格式
输入的第一行是一个整数T（T<=50），表示输入的数据组数。
每组测试数据的第一行是一个整数N（1<=N<=100），表示操作的数量。
没下来N行，每行按照上面的描述给出每个操作，输入保证所有的进程的PID都不相同，且一个进程结束后不会被重新启动，所有PID都是[1,100]之间的整数。

样例输入

5
FORK 0 1
QUERY 1
KILL 1
QUERY 1
QUERY 2

样例输出

Yes
No
No

解析

模拟。

#include <iostream>
#include <string>
#include <vector> 
#include <algorithm>
using namespace std;
int fa[101];
void kill(int t)
{
	fa[t]=-1;
	for(int i=1;i<101;i++)
	{
		if(fa[i]==t) kill(i);
	}
}

int main()
{
	int T;
	cin>>T;
	while(T--)
	{
		int N,x,y;
		fill(fa,fa+101,-1);
		cin>>N;
		while(N--)
		{ 
		string s;
		cin>>s;
			if(s=="FORK")
			{
				cin>>x>>y;
				fa[y]=x;
			}
			else if(s=="QUERY")
			{
				cin>>x;
				if(fa[x]!=-1||x==0) cout<<"Yes"<<endl;
				else cout<<"No"<<endl;
			}
			else if(s=="KILL")
			{
				cin>>x;
				kill(x);
			}
			} 
		
	}
	return 0;
}

D 网络传输

题目描述

网络的高效互联与智能传输是提升海量用户服务请求映射效率的重要措施。在这个任务中，你要用最少的传输时间，将特定的数据源发送到指定的网络节点中。
我么给定的网络一共包含N个节点（从1到N编号），其中节点1为数据源。网络中有M条无向边（u,v,w），表示一条传输线连接节点u和节点v，且数据通过这条传输线的平均时间为w。由于传送机制的限制，当一个节点接收到数据之后，它只能选择与它互连的一个节点，并将数据转发到该节点。节点1在初始化时只会发送一次数据，但在传输过程中它可以作为转发节点。
网络中有k个目标节点，你需要计算出该数据从节点1传送到所有K歌节点所需要的最短时间。注意目标节点可以按任意顺序进行传送，数据也可以多次经过同一节点。
输入格式
输入数据第一行是一个整数T（T<=5），表示测试数据的组数。
对于每组测试数据：
第一行是三个正整数N,M,K（2<=N<=1000，1<=M<=N(N-1)/2，K<=10），分别表示节点数，边数和目标节点数。
接下来M行，每行三个整数u,v,w（1<=u,v<=N, 0<=w<=1000,u!=v）。如上所述给出每条传输线。任意两个网络节点之间最多只会有一条边相连。
最后一行是K个整数，给出所有的目标节点的编号，所有目标节点的编号都在2到N之间。
输出格式
对于每组测试数据，输出数据传送到所有K个目标节点的最短时间。

样例输入

2
3 2 2
1 3 1
1 2 3
2 3
6 6 4
1 5 1
5 6 2
2 1 20
2 3 5
3 4 5
6 3 1
2 3 4 6

样例输出

5
19

说明：
在第一组样例中，最短路线是：1->3->1->2
在第二组样例中，最短路线是：1->5->6->3->2->3->4，或者1->5->6->3->4->3->2

解析

这道题用了全排列，next_permutation（a,a+n）

#include <iostream>
#include <algorithm>
#include <vector>
#define INF 0x3fffffff
#define MAXV 1005
using namespace std;
int G[MAXV][MAXV],vis[MAXV],d[MAXV],num[MAXV];
int T,n,m,k;
void 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[j][i]=G[i][k]+G[k][j];
			}
		}
	}
}
int main()
{
	cin>>T;
	while(T--)
	{
		fill(G[0],G[0]+MAXV*MAXV,INF);
		fill(vis,vis+MAXV,0);
		fill(d,d+MAXV,INF);
		cin>>n>>m>>k;
		for(int i=1;i<=n;i++) G[i][i]=0;
		int u,v,w;
		for(int i=0;i<m;i++)
		{
			cin>>u>>v>>w;
			if(w<G[u][v]) G[u][v]=G[v][u]=w;
		}
		for(int i=0;i<k;i++) cin>>num[i];
		floyd();
		int min=INF,sum=0,pre;
		do
		{
			sum=0;
			pre=1;
			for(int i=0;i<k;i++)
			{
				sum+=G[pre][num[i]];
				pre=num[i];
			}
			if(sum<min) min=sum;
		}while(next_permutation(num,num+k));
		cout<<min<<endl;
	}
	return 0;
 }