杭电2018复试上机真题

ps：题是别的地方copy过来的，代码是自己的

第一题:

//1.1
#include<cstdio>

using namespace std;

struct Movie{
	char name[20];
	int number;
}; 

bool isUgly(int x){
	while(x % 2 == 0){
		x /= 2;
	}
	while(x % 3 == 0){
		x /= 3;
	}
	while(x % 5 == 0){
		x /= 5;
	}
	return x == 1;
}

int main(){
	int n;
	scanf("%d",&n);
	Movie list[100];
	int length = 0;
	while(n--){
		scanf("%s%d",&(list + length)->name,&(list + length)->number);
		length++;
	}
	while(length--){
		if(isUgly((list + length)->number)){
			printf("%s\n",(list + length)->name);
		}
	}
	return 0;
} 

//1.2
#include<cstdio>
#include<algorithm>

using namespace std;

struct Movie{
	char name[20];
	int number;
}; 

bool cmp(Movie a,Movie b){
	return a.number > b.number;
}

int main(){
	int n;
	scanf("%d",&n);
	Movie list[100];
	int length = 0;
	while(n--){
		scanf("%s%d",&(list + length)->name,&(list + length)->number);
		length++;
	}
	sort(list,list + length,cmp);
	while(length--){
		printf("%s\n",(list + length)->name);
	}
	return 0;
} 

//1.3
#include<cstdio>
#include<cstring>

using namespace std;

struct Movie{
	char name[20];
	int number;
}; 

int main(){
	int n;
	scanf("%d",&n);
	Movie list[100];
	int length = 0;
	while(n--){
		scanf("%s%d",&(list + length)->name,&(list + length)->number);
		length++;
	}
	
	int insert = length / 2;
	
	Movie tmp;
	scanf("%s%d",&tmp.name,&tmp.number);
	
	for(int i = length;i > insert;i--){
		strcpy((list + i)->name , (list + i - 1)->name);
		(list + i)->number = (list + i - 1)->number;
	}
	
	strcpy((list + insert)->name,tmp.name);
	(list + insert)->number = tmp.number;
	
	length++;
	while(length--){
		printf("%s\n",(list + length)->name);
	}
	return 0;
} 

第二题:

注：19上机也出了类似的题，本身这种题属于计算机图像处理，我本科没做过这方向，不是很了解，个人感觉弄懂对于考试意义不大，所以我也不深究了。

 

第三题:

瓜农王大爷去年种西瓜赚了不少钱。看到收入不错，今年他又重新开辟了n个西瓜地。 
为了能给他的n个西瓜地顺利的浇上水，对于每个西瓜地他可以选择在本地打井，也可以修管道从另一个瓜地（这个瓜地可能打了井；也可能没打井，他的水也是从其他瓜地引来的）将水引过来。 
当然打井和修管道的费用有差别。已知在第i个西瓜地打井需要耗费wi元，在第i、j个西瓜地之间修管道需要耗费pi,j元。 
现在的问题是：王大爷要想使所有瓜地都被浇上水，至少需要花费多少钱（打井与修管道的费用和）？ 
由于瓜地较多，王大爷无法选择在哪些（个）瓜地打井，哪些西瓜地之间修管道。 
请你编程帮王大爷做出决策，求出最小费用。

（1<=N<=300，1<=wi<=100000；pi,i=0，1<=pi,j=pj,i<=100000）

input

第1行，一个正整数n，代表西瓜地的数量。 
以下n行，依次给出整数w1..wn（每块西瓜地的打井费用）。 
紧接着是一个n*n的整数矩阵，矩阵的第i行第j列的数代表pi,j（两块西瓜地之间建立管道的费用）。每行的两个数之间有一个空格隔开。

6
5
4
4
3
1
20
0 2 2 2 9 9
2 0 3 3 9 9
2 3 0 4 9 9
2 3 4 0 9 9
9 9 9 9 0 9
9 9 9 9 9 0

output

19

在第4个瓜地打井（费用为3），然后将第2,3，4个瓜地与第1个瓜地间修管道（费用分别是2,2,2），这样水可以经过管道从4流向1，然后经1再流向2和3； 
在第5个瓜地打井（费用为1），5和6之间修管道（费用为9）。 
这样一共打了2口井，修了4条管道，能给所有的6个瓜地浇水，费用是：3+2+2+2+1+9=19。 

//最小生成树
/*
    这里用了个巧办法。对于最典型的最小生成树来说，我一般用并查集以及边集来解决，并查集用来把通过最小边连起来的点进行合集，边集用来遍历最小边，点集的话用树的双亲表示法来表示，以便于表示自己的根结点。这题就是多了一个井的代价，巧办法就是，我可以把井也当做一个点，点的权值就相当于这个多出来的点到打井结点的路径长度，这样就把所有点权值转化为边权值，就是最小生成树的经典算法了。
    eg：看例子，有六个点，点权值分别为5,4,4,3,1,20，这时我们新加一个点，这个点到所有结点路径权值为点权值，加入我们的边集，相当于在原来基础上，又新加了6条边，这样就可以正常实现kruskal算法。
*/
#include<cstdio>
#include<algorithm>

using namespace std;

int tree[100];//双亲表示法的树，存放自己的双亲结点编号，-1则自身为根，初始所有结点都是-1

struct point{
	int cost;
};

struct edge{
	int from;
	int to;
	int cost;
};

int find(int x){  //查找根结点函数，实现了并查集的功能，这里加入了路径压缩，每次调用函数且在返回根结点序号之前，都会进行压缩，保证同一棵树中，查找根结点只需走一步，而不会出现那种单支树，影响查找效率
	if(tree[x] == -1){
		return x;
	}
	else{
		int tmp = find(tree[x]); //递归查找
		tree[x] = tmp;           //路径压缩
		return tmp;
	}
}

/*
不加入路径压缩，好理解一些
int find(int x){
    if(tree[x] == -1) return x;
    else return find(tree[x]);
}

*/

bool cmp(edge a,edge b){
	return a.cost < b.cost;
}

int main(){
	int num;
	scanf("%d",&num);
	
	point p[100];
	int Pnum = 0;
	for(int i = 0;i < num;i++){  //写入点权值
		scanf("%d",&(p + Pnum)->cost);
		Pnum++;
	}
	
	edge e[1000];
	int Enum = 0;
	int tmp;
	for(int i = 1;i <= num;i++){
		for(int j = 1;j <= num;j++){	//写入边权值，只需写入上或下三角形（只针对无向图邻接矩阵）
			if(i == j){
				scanf("%d",&tmp);
				continue;
			}
			else if(i > j){
				scanf("%d",&tmp);
				continue;
			}
			scanf("%d",&(e + Enum)->cost);
			(e + Enum)->from = i;
			(e + Enum)->to = j;
			Enum++;
		}
	}
	
    //点权值转化为边权值，放入边集
	for(int i = 0;i < Pnum;i++){
		(e + Enum)->from = 0;
		(e + Enum)->to = i + 1;
		(e + Enum)->cost = (p + i)->cost;		
		Enum++;		
	}
	 
	sort(e,e + Enum,cmp);  //边权值排序
	
	for(int i = 0;i < num + 1;i++){
		tree[i] = -1;  //初始化树
	}
	
    //基于kruskal的最小生成树算法
	int sum = 0;
	for(int i = 0;i < Enum;i++){  //遍历边集
		int a = find((e + i)->from);    //查找边对应的两个结点
		int b = find((e + i)->to);
		if(a != b){                     //如果结点根不同，则说明不连通，该边可以加入
			tree[a] = b;                //变更根结点
			sum += (e + i)->cost;
		}
	}
	
	printf("%d\n",sum);
	return 0;
}