数据结构第三次实验报告

二叉树最长路径 (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个整数，用空格分隔，表示最右侧的最长路径。

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

5
1 2 -1 -1 3 4 -1 -1 5 -1 -1
输出样例:
在这里给出相应的输出。例如：

2
1 3 5

思路

1.造树
2.找到一条最长的路
3.遍历最长的路中最右面的一条（递归从右侧开始遍历即可实现）

代码

#include<iostream>
using namespace std;
typedef struct node
{
	int value;
	struct node *left;
	struct node *right;
} TreeNode,*Tree;

void creat(Tree &T)
{
	int c;
	scanf("%d",&c);
	if(c==-1) T=NULL;
	else
	{
		T=new TreeNode;
		T->value=c;
		creat(T->left);
		creat(T->right);
	}
}

int depth(Tree T)
{
    if(T==NULL)
        return 0;
    else
    {
        int m=depth(T->left);
        int n=depth(T->right);
        if(m>n) return (m+1);
        else return (n+1);
    }
}

void printpath(Tree T, int path[], int pathlen,int d)
{
  int i;
  if(T != NULL) {
    path[pathlen] = T->value; 
    if(T->left == NULL && T->right == NULL) {
      if(pathlen==d-1)
      {
      	for(i =0; i<=pathlen; i++)
      	{
      		if(i==0)
      		cout << path[i];
      		else cout<<" "<<path[i];
		}
            
        cout << endl;
        exit(0);
	  }
        
    }else{
      printpath(T->right, path, pathlen + 1,d);
      printpath(T->left, path, pathlen + 1,d);
    }
  }
}
int path[100005];
int len=0;
int main()
{
	int p;
	scanf("%d",&p);
	Tree T;
	creat(T);
	int d=depth(T);
	cout<<d-1<<endl;
	printpath(T,path,len,d);
	
}

森林的层次遍历 (100 分)

题目

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

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

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

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

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

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

14
A B C D E F G H I J K L M N
4 0 3 0 0 0 0 2 2 0 0 0 1 0
输出样例:
在这里给出相应的输出。例如：

A M B C G H N D E F I L J K

思路

注意两点：
1.遍历的是森林而不是树
2.注意节点度为0的情况

使用了vector中的容器存储每个节点的儿子（若度不为0）

代码

#include<iostream>
#include<vector>
#include<queue>
using namespace std;
int m;
int dgr[100001];
char sri[100001][2];
vector<int>son[100001];
int tmp=0;
int ord=0;
int build()
{
    int num = ++ord;
    for (int i=1; i<= dgr[num]; i++)
    {
        son[num].push_back(build());
    }
    return num;
}
int main(){
cin>>m;
for (int i=0;i<m;++i)
    {
        cin>>sri[i];
    }
    for (int i=1;i<=m;++i)
    {
        cin>>dgr[i];
    }
    queue<int>s_on;
while(ord!=m){
    int temp = build();
    s_on.push(temp);
}
 while (!s_on.empty()){
        int cur=s_on.front();
        s_on.pop();
        cout<<sri[cur - 1];
        for(int i=0;i<dgr[cur]; i++)
            s_on.push(son[cur][i]);
           if(s_on.empty()) cout<<"\n";
           else cout<<" ";
    }
}

纸带切割 (100 分)

题目

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

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

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

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

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

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

5
5 6 7 2 4
输出样例:
在这里给出相应的输出。例如：

54

思路

使用了vector中的堆，建立一个小根堆，每次取最小的两个点进行加和，然后把两个数字的和再次放入队中，再重新建一个小根堆，重复上述流程直到最后容器中只有一个数字为止。
还使用了一个辅助栈来存储每次两个最小数加和的值，最后进行输出。

注意：
当只有一个数时的输出。

代码

#include <iostream>
#include <stack>
#include <vector>
#include <algorithm>
using namespace std;
vector<long long> v;
int N;

stack<long long> s;
int main()
{
	cin>>N;

	int r;

	long long sum=0;

	for(int i=0;i<N;i++)
	{
		cin>>r;
		if(N==1) {cout<<0<<endl;
                
                  exit(0);}
		v.push_back(r);
	}
	make_heap(v.begin(),v.end(),greater<int>());

	int z1,z2;
	while(v.size()!=1)
	{
		z1=v.front();
		pop_heap(v.begin(),v.end(),greater<int>());
		v.pop_back();

		z2=v.front();
		pop_heap(v.begin(),v.end(),greater<int>());
		v.pop_back();

        sum+=z1+z2;
		s.push(z1+z2);

		v.push_back(z1+z2);

		push_heap(v.begin(),v.end(),greater<int>());
	}
	cout<<sum<<endl;

    int op=1;
	while(s.size()!=op)
	{
		cout<<s.top()<<" ";

		s.pop();
	}
	cout<<s.top()<<endl;
}

序列乘积 (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个。

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

5
1 3 5 7 9
2 4 6 8 10
输出样例:
在这里给出相应的输出。例如：

2 4 6 6 8

思路

一开始没看到两个数组中的数都是递增的，所以把问题想复杂了，但是如果都是递增的话还是容易不少的，有几个需要注意的点：
1.要减少二重循环中的运算次数（通过设置条件）
2.可以先用一个数组存a[0]*b[i] (0<=i<=N),这样可以减少运算次数。
3.注意存储数组的大小（会影响过几个点）
4.可以使用堆排，也可以使用快排（这里用了系统自带的快排）

代码

#include<iostream>
#include<algorithm>
using namespace std;
int a[100500],b[100500];
int c[716500];
int main()
{
	int n;
	int k=1;
	scanf("%d",&n);
	for(int i=0;i<n;i++) scanf("%d",&a[i]);
	for(int i=0;i<n;i++) scanf("%d",&b[i]);
		int top=0;
    int tmp;
	for(int i=0;i<n;i++)
		c[top++]=a[0]*b[i];
	for(int i=1;i<n;i++)
	{
		for(int k=0;k<n;k++)
		{
			tmp=a[i]*b[k];
			if(tmp>c[n-1])
			{
				if(k==0)
					goto e;
				else
					break;
			}
			c[top++]=tmp;
		}
        if(top>=2*n)
		{
			sort(c,c+top);
			top=n;
		}
	}
e:
	sort(c,c+top);
	  for(int i=0;i<n;i++)
	  if(i==0) printf("%d",c[i]);
	  else printf(" %d",c[i]);
	  printf("\n");
 }