NEUQ—ACM实验班2.4小测试反思总结

1.一元多项式的乘法与加法运算 (5 分)
设计函数分别求两个一元多项式的乘积与和。

输入格式:
输入分2行，每行分别先给出多项式非零项的个数，再以指数递降方式输入一个多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。

输出格式:
输出分2行，分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。零多项式应输出0 0。

输入样例:
4 3 4 -5 2 6 1 -2 0
3 5 20 -7 4 3 1
输出样例:
15 24 -25 22 30 21 -10 20 -21 8 35 6 -33 5 14 4 -15 3 18 2 -6 1
5 20 -4 4 -5 2 9 1 -2 0

分析：（为什么一到模拟我就拉跨），我们先用两个数组分别存两个多项式，让下标作为指数，系数作为数组的数，之后再分别用两个数组存放相加和相乘的结果，最后注意输出格式即可

#include<bits/stdc++.h>
using namespace std;

const int N = 1e4+10;
int a[N],b[N],c[N],d[N];
int n,m;

int main()
{
	 cin >> n;
	 while (n --)
	 {
	 	int x,y;
	 	cin >> x >> y;
	 	a[y] += x;
	 }
	 
	 cin >> m;
	 while (m --)
	 {
	 	int x, y;
	 	cin >> x >> y;
	 	b[y] += x;
	 }
	 
	for (int i= N-1;i>=0;i--)
	{
		if(a[i]) //a[i]系数不是0
		{
			for (int j=N-1;j>=0;j--)
			{
				if(b[j]) c[i+j] += a[i] * b[j]; //i+j是相乘指数相加后和的下标，同时系数相乘！！！精彩，前提是b[i]的系数存在
			}
		}
	}
	
	for (int i=N-1;i>=0;i--)
	{
		if(a[i]) d[i] += a[i]; //这里；两次if，如果指数相同就系数相加
		if(b[i]) d[i] += b[i];
	}
	
	int cnt1 = 0;
	for (int i = N-1;i>=0;i--) //从高到低输出，注意逆序
	{
		 if(c[i])
		 {
		 	if(cnt1) cout << " "; //首项不用空格
		 	if(c[i]) cout << c[i] << " "<< i ; //系数，指数
		 	cnt1 ++;
		 }
	}
	
	cout << endl;
	
	int cnt2 = 0;
	for (int i = N -1;i>=0;i--)
	{
		if(d[i])
		{
			if(cnt2) cout << " ";
			if(d[i]) cout << d[i] << " " << i;
			cnt2++;
		}
	}
	
	return 0;
}

2.根据后序和中序遍历输出先序遍历 (10 分)
本题要求根据给定的一棵二叉树的后序遍历和中序遍历结果，输出该树的先序遍历结果。

输入格式:
第一行给出正整数N(≤30)，是树中结点的个数。随后两行，每行给出N个整数，分别对应后序遍历和中序遍历结果，数字间以空格分隔。题目保证输入正确对应一棵二叉树。

输出格式:
在一行中输出Preorder: 以及该树的先序遍历结果。数字间有1个空格，行末不得有多余空格。

输入样例:
7
2 3 1 5 7 6 4
1 2 3 4 5 6 7

输出样例:
Preorder: 4 1 3 2 6 5 7

#include <bits/stdc++.h>
using namespace std;
int post[50] , ino[50]; //定义全局变量
typedef struct btnode {
	int data;
	struct btnode *lchild,*rchild;
}btnode , *btree;

btree buildetree(int root,int start,int end);//root为后序根节点，start为中序开始，end为中序结尾
void DLRtree(btree bt);

int main(){
	btree bt;
	int N; cin>>N;
	int i;
	for(i=0;i<N;i++){
		int x; cin>>x;
		post[i] = x;
	}
	for(i=0;i<N;i++){
		int x; cin>>x;
		ino[i] = x;
	}
	bt = buildetree(N-1,0,N-1);//root在第N-1个位置，start开始在0位置，end在第N-1个位置
	cout<<"Preorder:";
	DLRtree(bt);
	return 0;
}

btree buildetree(int root,int start,int end){
	if(start>end) return 0;
	btree bt;
	int i;
	for(i=start;post[root] !=ino[i];i++);
	bt = new btnode;
	bt->data = post[root];
	bt->lchild = buildetree(root-(end-i)-1,start,i-1);
	bt->rchild = buildetree(root-1,i+1,end);
//下面图片
	return bt;
}

void  DLRtree(btree bt){
	if(bt == NULL) return;
    cout<<" "<<bt->data ;
    DLRtree(bt->lchild );
    DLRtree(bt->rchild );
}

7-10 顺序存储的二叉树的最近的公共祖先问题 (10 分)
设顺序存储的二叉树中有编号为i和j的两个结点，请设计算法求出它们最近的公共祖先结点的编号和值。

输入格式:
输入第1行给出正整数n（≤1000），即顺序存储的最大容量；第2行给出n个非负整数，其间以空格分隔。其中0代表二叉树中的空结点（如果第1个结点为0，则代表一棵空树）；第3行给出一对结点编号i和j。

题目保证输入正确对应一棵二叉树，且1≤i,j≤n。

输出格式:
如果i或j对应的是空结点，则输出ERROR: T[x] is NULL，其中x是i或j中先发现错误的那个编号；否则在一行中输出编号为i和j的两个结点最近的公共祖先结点的编号和值，其间以1个空格分隔。

输入样例1：
15
4 3 5 1 10 0 7 0 2 0 9 0 0 6 8
11 4
输出样例1：
2 3
输入样例2：
15
4 3 5 1 0 0 7 0 2 0 9 0 0 6 8
12 8
输出样例2：
ERROR: T[12] is NULL

分析：运用递归，如果不再同一层，则大的递归，最后判断二者是否有同样的根节点，如果在同一层但根节点不一样则再此递归直到相同为止

#include<bits/stdc++.h>
using namespace std;

int find(int a,int b)
{
     if (a == b ) return a;
     if (a < b ) return find(a , b/2);
     if (a > b ) return find(a/2 , b);
}      
int main()
{
     int a[1005];
     int n ,i,j;
     cin >> n;
     for (int x=1 ;x<=n;x++) cin>> a[x];
     
     cin >> i >> j;
     if(a[i] == 0 ) printf("ERROR: T[%d] is NULL",i);
     else if (a[j] == 0 ) printf("ERROR: T[%d] is NULL",j);

      else 
      {
         int p = find (i,j);
         cout << p << " " << a[p] <<endl;
      }
     return 0;
}
    

注意在前面两个判断里，用printf 输出更为快捷；

3 . 朋友圈 (25 分)
某学校有N个学生，形成M个俱乐部。每个俱乐部里的学生有着一定相似的兴趣爱好，形成一个朋友圈。一个学生可以同时属于若干个不同的俱乐部。根据“我的朋友的朋友也是我的朋友”这个推论可以得出，如果A和B是朋友，且B和C是朋友，则A和C也是朋友。 请编写程序计算最大朋友圈中有多少人。

输入格式:
输入的第一行包含两个正整数N（≤30000）和M（≤1000），分别代表学校的学生总数和俱乐部的个数。后面的M行每行按以下格式给出1个俱乐部的信息，其中学生从1~N编号：

第i个俱乐部的人数Mi（空格）学生1（空格）学生2 … 学生Mi

输出格式:
输出给出一个整数，表示在最大朋友圈中有多少人。

输入样例:
7 4
3 1 2 3
2 1 4
3 5 6 7
1 6
输出样例:
4

分析：经典的并查集搜索，在维护的并查集的基础上加入对子集个数的合并即可

#include<bits/stdc++.h>
using namespace std;

const int N = 1e5+10;
int p[N];
int pre[N];//输入的成员变量
int cnt[N];//统计每个子集中元素的数量，注意在维护并查集时候，我们只认为根节点的size有意义（只加到根节点上）
int n ,m ;

int find(int x)
{
	if (p[x] != x) p[x] = find(p[x]); //路径压缩
	return p[x];
}

int main()
{
	cin >> n >> m;
	
	for (int i=1;i<=n;i++) //初始化并查集
	{
			p[i] = i;
			cnt[i] = 1;
	} 
	
	while (m --)
	{
		int k= 0;
		cin >> k;
		
		for (int i=1;i<=k;i++) cin >> pre[i];
		
		
		for (int i =1;i<=k;i++)
		{
			for (int j =i+1;j<=k;j++)
			{
				int x , y; 
				x = find(pre[i]) ,y = find(pre[j]);
				
				if(x != y) //判断是否为同一个根节点
		        {
					p[x] = y; 插到另一个根节点上去
					cnt[y] += cnt[x];	合并子集，注意方向
				}
				
	         	else if(x == y) continue; 跳过，增加循环速度
			}
		}
		
	}
	
	int res = 0;
	for (int i=0;i<=n;i++) res = max (res , cnt[i]); 这里用cnt[find(i)] 也可，因为我们已经维护的是根节点的大小了，没有必要再找一遍根节点去了
	
	cout << res << endl;
	
	return 0;
}

whx沃斯逆蝶