数据结构荣誉课--第三次实验解题报告

Posted 2021-06-08 qq_52090648

数据结构荣誉课--第三次实验解题报告

• • 7-1 二叉树最长路径 (100 分)
  • • 题目
    • 思路
    • 代码
  • 7-2 森林的层次遍历 (100 分)
  • • 题目
    • 思路
    • 代码
  • 7-3 纸带切割 (100 分)
  • • 题目
    • 思路
    • 代码
  • 7-4 序列乘积 (100 分)
  • • 题目
    • 思路
    • 代码

7-1 二叉树最长路径 (100 分)

题目

给定一棵二叉树T，求T中的最长路径的长度，并输出此路径上各结点的值。若有多条最长路径，输出最右侧的那条。

输入格式:
第1行，1个整数n，表示二叉树有n个结点， 1≤n≤100000.

第2行，2n+1个整数，用空格分隔，表示T的扩展先根序列， -1表示空指针，结点用编号1到n表示。

输出格式:
第1行，1个整数length，length表示T中的最长路径的长度。

第2行，length+1个整数，用空格分隔，表示最右侧的最长路径。

输入样例:
在这里给出一组输入。例如：

输出样例:
在这里给出相应的输出。例如：

思路

• 思路一： 一开始用了先求树的高度，再遍历打印最长路径的方法，但一直有一个测试点因为超时过不去，我以为是我使用递归的原因，消了递归还是过不去后来觉得应该是函数内调用函数的原因，这里给出思路一的代码：

int getheight(Tree T) {//第一个方法：递归求树的高度
	if (T == NULL) return 0;
	int x, y;
	x = getheight(T->left);
	y = getheight(T->right);
	return max(x, y) + 1;
}
int Treelong1(Tree T) {//第二个方法：使用队列求出树的高度
	queue<Node*> q;
	if (!T) return 0;
	q.push(T);
	int level = 0;
	while (!q.empty())
	{
		int len = q.size();
		level++;
		while (len--) {
			Tree tmp = q.front();
			q.pop();
			if (tmp->left) q.push(tmp->left);
			if (tmp->right) q.push(tmp->right);
		}
	}
   while (!q.empty())
	{
		//int t = q.front()->data;
		q.pop();

	}
	return level;//返回树的高度
}
void Findlong(Tree T, int k) {//遍历打印最长路径
	int K=k;
	for (int i = 0; i < K; i++) {
		if (T != NULL) {
			k--;
			printf("%d", T->data);
			if (k != 0) printf(" ");//符合格式要求
			if (getheight(T->left) > getheight(T->right))//or 使用Treelong1函数
				T = T->left;                            //比较两字树的高度，哪边高往哪边走
			else T = T->right;
		}
	}
}

• 思路二：虽然使用的是递归，但没有超市，说明这道题多使用几次递归是不会超时的，但在函数内嵌套使用其他函数会超时。思路如下：递归建树，遍历树，将树的结点存入一个数组，设两个变量len和longestlen，分别表示当前走过路径的长度和最长路径，如果len大于longestlen就更新longestlen，再将当前路径的各结点存入最长路径结点的数组longestpath，递归进行遍历直到递归出口。
  最后打印出longestpath里的树的结点，此处要注意格式要求。

代码

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
using namespace std;
typedef struct node {
	int data;
	struct node* left;
	struct node* right;
}Node,*Tree;
void BuildTree(Tree &T, int n){
	int data;
	int i = 0;
	scanf("%d", &data);
	if (data ==-1) {
		T = NULL;
		return;
	}
	else if (data != -1 && i <= n) {
		if (!(T = (Tree)malloc(sizeof(Node)))) exit(0);
		i++;
		T->data = data;
		BuildTree(T->left,n);
		BuildTree(T->right,n);
	}
}

void longest_path(Tree T, int* path, int& len, int* longestpath, int& longestlen) {
	if (T != NULL) {
		if (T->left == NULL && T->right == NULL) {
			path[len] = T->data;
			if (len >= longestlen) {
				for (int j = 0; j <= len; j++) {
					longestpath[j] = path[j];
				}
				longestlen = len;
			}
		}
		else {
			path[len++] = T->data;
			longest_path(T->left, path, len, longestpath, longestlen);
			longest_path(T->right, path, len, longestpath, longestlen);
			len--;
		}
	}
}

int main() {
	int n;
	Tree T;
	scanf("%d", &n);
	BuildTree(T, n);
	int path[100000] = { 0 };
	int longestpath[100000] = { 0 };
	int len = 0;
	int longestlen = 0;
	longest_path(T, path, len, longestpath, longestlen);
	printf("%d\\n", longestlen);
	for (int i = 0; i <= longestlen; i++) {
		printf("%d", longestpath[i]);
		if (i != longestlen) printf(" ");
	}
}

7-2 森林的层次遍历 (100 分)

题目

给定一个森林F，求F的层次遍历序列。森林由其先根序列及序列中每个结点的度给出。

输入格式:
第1行，1个整数n，表示森林的结点个数， 1≤n≤100000.

第2行，n个字符，用空格分隔，表示森林F的先根序列。字符为大小写字母及数字。

第3行，n个整数，用空格分隔，表示森林F的先根序列中每个结点对应的度。

输出格式:
1行，n个字符，用空格分隔，表示森林F的层次遍历序列。

输入样例:
在这里给出一组输入。例如：

输出样例:
在这里给出相应的输出。例如：

思路

• 先用递归方法建树，由于题目给的是森林，不止建一棵数，所以需要初始化一个变量num，记录处理的结点，num=n的时候表示森林已建成。
• 用两个数组分别保存结点的值和结点的度，再利用vector的儿子链把每个结点的儿子保存起来，以此实现层次遍历。

代码

#define _CRT_SECURE_NO_WARNINGS
#include "iostream"
#include "queue"
#include "vector"
using namespace std;
char Node[100001][2];
int Nodenum[100001];
vector<int> s[100001];
int num = 1;
void Buildonetree(int n) {
	for (int i = 0; i < Nodenum[n]; i++) {
		s[n].push_back(++num);
		Buildonetree(num);
	}
}
int main() {
	int n;
	queue<int> q;
	scanf("%d", &n);
	for (int i = 1; i <= n; i++) {
		scanf("%s", Node[i]);
	}
	for (int i = 1; i <= n; i++) {
		scanf("%d", &Nodenum[i]);
	}
	while (num<=n)
	{
		s[0].push_back(num);
		Buildonetree(num);
		num++;
	}
	q.push(0);
	while (!q.empty()){
		int x = q.front();
		q.pop();
		for (vector<int>::iterator i = s[x].begin(); i != s[x].end(); i++) q.push(*i);
		if (x) printf("%s", Node[x]);
		if (!q.empty()&&x!=0) printf(" ");
	}
}

7-3 纸带切割 (100 分)

题目

有一条细长的纸带,长度为 L 个单位，宽度为一个单位。现在要将纸带切割成 n 段。每次切割把当前纸带分成两段，切割位置都在整数单位上，切割代价是当前切割纸带的总长度。每次切割都选择未达最终要求的最长纸带切割，若这样的纸带有多条，则任选一条切割。如何切割，才能完成任务，并且总代价最小。

输入格式:
第1行，1个整数n，表示切割成的段数， 1≤n≤100000.

第2行，n个整数Li，用空格分隔，表示要切割成的各段的长度，1≤Li≤200000000，1≤i≤n.

输出格式:
第1行，1个整数，表示最小的总代价。

第2行，若干个整数，用空格分隔，表示总代价最小时每次切割的代价。

输入样例:
在这里给出一组输入。例如：

输出样例:
在这里给出相应的输出。例如：

思路

• 刚开始看这道题是时候没读懂题目，听了同学的讲解，才发现是可以从样例看出来此题要用哈夫曼树。先建一个单调递增的优先队列（先写的第四题，写的时候看大佬用了优先队列，发现也可以用的这道题上），每次弹出两个最小元素，相加压入对内，每次的和保存在一个数组里，于此同时初始化一个变量sum，保存最小总代价，最后再将数组中的元素反向打印，此处要注意格式要求。

代码

#define _CRT_SECURE_NO_WARNINGS
#include "iostream"
#include "iomanip"
#include "queue"
using namespace std;
//priority_queue<long long> q;
priority_queue<long long, vector<long long>, greater< long long> >q;
long long a[100000];
long long b[100000];
int len = 0;
int main() {
	int n;
	long long sum = 0;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%lld", &a[i]);
		q.push(a[i]);
	}
	while (q.size() > 1) {
		long long tmp1 = q.top();
		q.pop();
		long long tmp2 = q.top();
		q.pop();
		sum += tmp1 + tmp2;
		b[len] = tmp1 + tmp2;
		len++;
		q.push(tmp1 + tmp2);
	}
	printf("%lld\\n", sum);
	for (int i = len-1; i >=0; i--) {
		printf("%lld", b[i]);
		if (i !=0) printf(" ");
	}
}

7-4 序列乘积 (100 分)

题目

两个递增序列A和B,长度都是n。令 Ai 和 Bj 做乘积，1≤i,j≤n.请输出n*n个乘积中从小到大的前n个。

输入格式:
第1行，1个整数n，表示序列的长度， 1≤n≤100000.

第2行，n个整数Ai，用空格分隔，表示序列A，1≤Ai≤40000，1≤i≤n.

第3行，n个整数Bi，用空格分隔，表示序列B，1≤Bi≤40000，1≤i≤n.

输出格式:
1行，n个整数，用空格分隔，表示序列乘积中的从小到大前n个。

输入样例:
在这里给出一组输入。例如：

输出样例:
在这里给出相应的输出。例如：

思路

• 最开始使用了暴力法。将所有的运算结果保存在一个数组，再使用sort函数排序数组，最后将前n个数打印出来，此方法因为内存超限，只得了60分。
  代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<algorithm>
using namespace std;
const int MAX = 1e8+ 3;
int sum[MAX];
int main() {
	int n,k=0;
	scanf("%d", &n);
	int A[100000], B[100000];
	for (int i=0; i < n; i++) scanf("%d", &A[i]);
	for (int i=0; i < n; i++) scanf("%d", &B[i]);
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			sum[k] = A[i] * B[j];
			k++;
		}
	}
	sort(sum, sum + k-1);
	for (int t = 0; t < n; t++) {
        printf("%d", sum[t]);
        if(t!=n-1) printf(" ");}

}

• 显示内存超限的时候我以为是我开的保存运算结果的数组不够大，然后试着只保存前n个结果，每保存n个数排序一次，将新的结果跟数组最后一个元素比较，如果新的结果小则更新数组最后一个元素，再次排序，以此类推，但发现还是不行。此题主要卡的点是运算结果的时候效率是O（n^2）的，所以要减少运算次数。看了大佬的代码，知道了可以使用结构体优先队列。
• 开一个优先队列维护一个小根堆，分别保存一个数的数值，所在的行数和列数。将乘积看做是两个矩阵的乘法，从样例是以递增顺序给的，所以最小的数值只能出现在矩阵每行的最左端。一开始只需算A数组的第一个元素和B组元素的乘积将结果压入堆中，然后每次取最小后再把这个数右边的运算结果放入堆中。
• 要注意格式要求。

代码

#define _CRT_SECURE_NO_WARNINGS
#include<queue>
#include<iostream>
using namespace std;
struct node {
	int i, j;
	long long data;
};
bool operator<(const node& p, const node& q) {
	return p.data > q.data;
}
priority_queue<node> q;
long long A[100001], B[100001];
int main() {
	node C;
	int n, k = 1,j=0;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) scanf("%lld", &A[i]);
	for (int i = 0; i < n; i++) scanf("%lld", &B[i]);
	for (int i = 0; i < n; i++) {
		 C.data= A[i] * B[0];
		 C.i = i;
		 C.j = 0;
		q.push(C);
	}
    for(int i=0;i<n;i++){
		node tmp = q.top();
		q.pop();
		printf("%lld", tmp.data);
		if (i != n - 1) printf
以上是关于数据结构荣誉课--第三次实验解题报告的主要内容，如果未能解决你的问题，请参考以下文章
 
 数据结构荣誉课--第三次实验解题报告
 数据结构荣誉课--第三次实验解题报告
 数据结构荣誉课---第一次实验解题报告
 数据结构荣誉课---第一次实验解题报告
 数据结构荣誉课---第一次实验解题报告
 数据结构荣誉课---第一次实验解题报告