22 计专

数据结构

第一题

1、具有n个顶点的无向图G,领接矩阵的上三角部分（不含主对角线），按照列优先顺序存储在一维数组A中（下标从0开始），编写算法统计各节点的度
思路：

1. 主要是如何把现有的一维数组转化为二维数组，找到下标之间对应的关系
2. 因为是按列存储，从每列出发，遍历上三角部分，如果行与列不相等，就赋值，同时由于是无向图，所以可以一次性的完成矩阵的赋值，具有对称性，同时一维数组的下标加1

代码：

//1、具有n个顶点的无向图G,领接矩阵的上三角部分（不含主对角线），按照列优先顺序存储在一维数组A中（下标从0开始），编写算法统计各节点的度
void FindDegree(int a[], int n, int len){
	int i,j,k=0,row,col;
	int A[n][n];
	int indgree[n] = {0};
	int outdgree[n] = {0}; 
	
	for(i = 0; i < n && k < len; i++){		//先恢复A矩阵，包括对角线 
		for(j = 0;  j <=i; j++){
			if(i==j){
				A[i][j] = 0;
			}	
			else{							//因为为对称阵，所以直接可以恢复 
				A[j][i] = a[k];
				A[i][j] = a[k];
				k++;
			}
		}
	}
	
	for(i=0; i < n; i++){		//计算入度与出度 
		col = 0;
		row = 0;
		for(j=0; j < n; j++){
			if(A[i][j] != 0){
				row++;
			} 
			if(A[j][i] != 0){
				col++;
			}
		}
		indgree[i] = col;
		outdgree[i] = row;
		printf("顶点%d的出度为%d，入度为%d\n",i,row,col);
	}
}

第二题

2、编写算法判断无向带权图G的最小支撑树是否唯一
思路：

1. 利用kruskal算法，首先明确一点，对于无向带权图中，如果所有的权值都不同，那么只有唯一的最小生成树。但是存在权值相同的边，也可能也有唯一的最小生成树，主要看这些相同权值的边，能否构成对应的并查集，即一条边与另外一条权值相同的边，是否可以构成权值相同的具有相同点的连通分量。
2. 主要算法思路，在kruskal算法执行过程中，先求当前节点权值相同的节点，判断这些权值是否可以构成一个无回路的连通分量，如果可以，说明可以加入当前最小生成树，统计可以加入的数量，然后再构建最小生成树，在构建的过程中，每构建一次，就对当前统计的数量减1，如果最后存在可以构建的边，但是没有构建完，说明最小生成树不唯一

代码：

//2、编写算法判断无向带权图G的最小支撑树是否唯一 
//kruskal算法的实现
/*
如果最小生成树权值全部不一样，那么最小生成树是唯一的，
如果图中存在权值相等的边，那么最小生成树中，可能存在不同的最小生成树，关键是，当前的两条边是否能够成功构成一个连通分量
主要的算法思路是，在求最小生成树的过程中，权值相等的变，若是都可以选择，则应该都要选择，如果只选了一条，则不存在 
*/ 

typedef struct node{		//边起点、终点、权值 
	int from;
	int to;
	int weight;
}node;

typedef struct EdgeGraph{	//存储边的图 
	node e[maxsize];
	int vexnum, arcnum;
}EdgeGraph;

int cmp(const void *a, const void *b){		//qsort自定义递增排序 
	return ((node *)a)->weight-((node*)b)->weight;
} 

int find(int parent[], int x){		//找到根节点 
	int t = x;
	while(parent[t] != -1){
		t = parent[t];
	}
	return t;
} 

int kruskcal(EdgeGraph *G, int &sum){
	int parent[G->arcnum];
	int i=0,j,r,a,b,num=0;
	for(i=0; i < G->arcnum; i++){					//初始化并查集 
		parent[i] = -1;
	}
	
	qsort(G->e, G->arcnum, sizeof(node), cmp); 		//排序 
	i=0;
	while(i < G->arcnum){
		r = i;									//r指向当前相同权值最后一条边的下一个顶点 
		while(r<G->arcnum && G->e[i].weight == G->e[r].weight){
			r++;
		}
		for(j=i; j < r; j++){					//在权值相同的边中，如果都可以构成没有回路的路径，则说明都可以取 
			a = find(parent,G->e[j].from);
			b = find(parent,G->e[j].to);
			if(a != b){
				num++;
			}
		}
		for(j=i; j < r; j++){					//依次取这些边，判断是否取干净 
			a = find(parent,G->e[j].from);
			b = find(parent,G->e[j].to);
			if(a != b){						//计算最小生成树，判断可取的边是否取完 
				parent[a] = b;
				sum+=G->e[j].weight;
				num--;
			}
		}
		i = r;			//从下一条不同权值的边开始取
		if(num !=0) return 0;			//如果没有取完，则说明存在不唯一的最小生成树 
	}
	return 1;		
}

高级语言

第一题

编写程序，调和级数H，要求以最贱分数形式A/B输出，例如n=5,输出137/60,H = 1+1/2+1/3+1/4+…+1/n;
思路： 分子与分母分开求，先求分母，然后再求分子，最后求公因子，相处公因子即可得到

//求最小公约数
int comdiv(int a, int b){		//默认a>b
	int c;
	while(b){		//辗转相除法
		c = a%b;
		a = b;
		b = c;
	}
	return a;
} 

//求调和级数的最贱分数形式 
void OutHramPro(int ans){
	int m=1,n=1,i;		//m为分子，n为分母
	int temp;
	for(i = 2; i <= ans; i++){
		temp = comdiv(m*i+n,n*i);
		m = (m*i+n)/temp;
		n = n*i/temp;
	}
	printf("%d/%d",m,n);
}

第二题

4、已知回文字是有字母和数字组成的连续串，假设回文串的长度不超过45，从键盘中读取任意长度的字符串，可能还有空格，制表符，回车换行等字符，以@结束编写程序，统计其中出现的回文串个数

思路： 最简单就直接暴力，统计每个字符长度从1到n判断是否为回文串，如果是就+1，但是时间复杂度有点高，这里采用中心扩散的算法

中心扩散算法：

1. 中心有两种，第一种是以一个字母为中心，第二个是以两个字母为中心，然后依次向两边扩散，如果扩散之后发现，左指针和右指针都相同，说明是回文串，个数加1

//中心扩散算法
int count(char *s, int l, int r){
	int n = strlen(s);
	int count=0; 
	while(l >=0 && r < n && s[l]==s[r]){
		l--;
		r++;
		count++;
	}
	return count;
} 

//两种中心
int countSubstrings(char *s){
	int ans=0,i;
	int n = strlen(s);
	for(i=0;i<n; i++){
		ans+=count(s,i,i);
	} 
	for(i=0;i<n-1; i++){
		ans+=count(s,i,i+1);
	} 
	return ans;
} 

第三题

5、给定N张纸牌，每张纸牌均正面朝上，第一次将所有在二和二的倍数的位置上的纸牌翻面，第二次将3和3的倍数上的纸牌翻面，一直翻到要翻第n张为止，求正面朝上的纸牌的个数和其位置
**思路：**按要求进行模拟即可

//5、给定N张纸牌，每张纸牌均正面朝上，第一次将所有在二和二的倍数的位置上的纸牌翻面，第二次将3和3的倍数上的纸牌翻面，一直翻到要翻第n张为止，求正面朝上的纸牌的个数和其位置
int ReserseCard(int a[], int b[], int n){		//a存放纸牌，b存放正面朝上的位置
	int i,j,count=0;
	 for(i=2; i < n;i++){	//要翻但是还没翻 
	 	j = i;
	 	while(j<=n){
	 		if(a[j]==1) a[j] = 0;		//对纸牌进行翻面 
	 		else a[j] = 1;
	 		j += i; 
		 }
	 }
	 for(i=1; i<= n; i++){			//记录正面朝上的个数以及位置 
	 	if(a[i]==1){
	 		b[count++] = i;
		 }
	 } 
	 return count;
}