Problem 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
#include<iostream>
using namespace std;
//求2的x次方
int power(int x){
int num=1;
while(x--){
num*=2;
} return num;
}
int main(){
int a,b,n;
cin>>n;
while(n--){
cin>>a>>b;
if(a>b) swap(a,b);
int x=b-a;
if(!x) printf("1/%d\n",power(b-1));
else printf("%d/%d\n",power(x)+1,power(b));
}
return 0;
}
Problem 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>
using namespace std;
const int maxn=110;
int w[maxn];
int main(){
int t;
cin>>t;
while(t--){
int n;
cin>>n;
for(int i=1;i<=n;i++) cin>>w[i];
bool flag=true;
for(int i=1;i<n;i++){
int u,v;
cin>>u>>v;
if(w[u]>w[v]) flag=false;
}if(flag) printf("YES\n");
else printf("NO\n");
}
return 0;
}
第三个这个文档里面的样例给的不对，我认为不对，按照自己理解写了下，嗯。
Problem 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
Yes
#include<iostream>
#include<vector>
#include<string>
using namespace std;
const int maxn=110;
struct node{
int status,father;
vector<int> child;
}root[maxn];
bool fork(int pid1,int pid2){
if(!root[pid1].status) return false;
root[pid1].child.push_back(pid2);
root[pid2].status=1;
root[pid2].father=pid1;
return true;
}
void kill(int pid){
if(!pid) return;
root[pid].status=0;
while(root[pid].child.size()){
int c=*root[pid].child.begin();
kill(c);
}
int f=root[pid].father;
root[f].child.erase(root[f].child.begin());
}
bool query(int pid){
if(root[pid].status) return true;
else return false;
}
int main(){
int t;
cin>>t;
root[0].status=1;
for(int i=1;i<maxn;i++) root[i].status=0;
while(t--){
string s;
cin>>s;
if(s=="FORK"){
int pid1,pid2;
cin>>pid1>>pid2;
if(!fork(pid1,pid2)) printf("NO\n");
else printf("YES\n");
}else{
int pid;
cin>>pid;
if(s=="QUERY"){
if(query(pid)) printf("YES\n");
else printf("NO\n");
}else{
kill(pid);
}
}
}
return 0;
}
看起来庞大的一道题，迪杰斯特拉然后再每个结点求最短路径，emmm
Problem 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
#include<iostream>
#include<vector>
using namespace std;
const int maxn=110;
const int inf=0x3fffffff;
int n,m,k;
int G[maxn][maxn];
bool vis[maxn];
int d[maxn];
vector<int> quary;
void Dijkstra(int s){
fill(d,d+maxn,inf);
fill(vis,vis+maxn,false);
d[s]=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) return;
vis[u]=true;
for(int v=1;v<=n;v++){
if(!vis[v]&&d[u]+G[u][v]<d[v]&&G[u][v]!=inf){
d[v]=d[u]+G[u][v];
}
}
}
}
int main(){
int t;
cin>>t;
while(t--){
fill(G[0],G[0]+maxn*maxn,inf);
cin>>n>>m>>k;
for(int i=0;i<m;i++){
int u,v,w;
cin>>u>>v>>w;
G[u][v]=G[v][u]=w;
}int now=1,dis=0;
for(int i=0;i<k;i++){
int q;
cin>>q;
quary.push_back(q);
}
while(quary.size()){
Dijkstra(now);
int min=0;
for(int i=1;i<quary.size();i++){
if(d[quary[i]]<d[quary[min]]) min=i;
}dis+=d[quary[min]];
now=quary[min];
quary.erase(quary.begin()+min);
}
cout<<dis<<endl;
}
return 0;
}