数据结构第六次上机实验

7-1 高精度数加法 (100 分)

高精度数是指大大超出了标准数据类型能表示的范围的数，例如10000位整数。很多计算问题的结果都很大，因此，高精度数极其重要。

一般使用一个数组来存储高精度数的所有数位，数组中的每个元素存储该高精度数的1位数字或多位数字。 请尝试计算：N个高精度数的加和。这个任务对于在学习数据结构的你来说应该是小菜一碟。 。

输入格式:

第1行，1个整数N，表示高精度整数的个数，(1≤N≤10000)。

第2至N+1行，每行1个高精度整数x, x最多100位。

输出格式:

1行,1个高精度整数，表示输入的N个高精度数的加和。

输入样例:

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

3
12345678910
12345678910
12345678910

输出样例:

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

37037036730

题目分析

用数组存大整数的一位数字，每次计算考虑一下进位即可。

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

#define max 10010
int sum[max];
char tema[max],temb[max];
int main(){
	int n,l=0,p=0,v,maxn=0,h=0;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("\n%s",tema);
		int k=strlen(tema);
		if(k>=maxn)maxn=k;
		for(int j=0;j<k;j++){temb[k-1-j]=tema[j];}
		for(int j=0;j<k;j++){
			v=temb[j]-'0';
			sum[j]+=v;
		}
	}
	while(h<maxn){
		l=sum[h]%10;
		p=sum[h]/10;
		sum[h]=l;
		sum[h+1]+=p;
		if(p&&h+1>=maxn)maxn++;
		h++;
	}
    //printf("%d %d\n",maxn,h);
	for(int i=maxn-1;i>=0;i--){
		printf("%d",sum[i]);
	}
	return 0;
}

7-2 二叉树加权距离 (100 分)

二叉树结点间的一种加权距离定义为：上行方向的变数×3 +下行方向的边数×2 。上行方向是指由结点向根的方向，下行方向是指与由根向叶结点方向。 给定一棵二叉树T及两个结点u和v，试求u到v的加权距离。

输入格式:

第1行，1个整数N，表示二叉树的结点数，(1≤N≤100000)。

随后若干行，每行两个整数a和b，用空格分隔，表示结点a到结点b有一条边，a、b是结点的编号，1≤a、b≤N；根结点编号为1，边从根向叶结点方向。

最后1行，两个整数u和v，用空格分隔，表示所查询的两个结点的编号，1≤u、v≤N。

输出格式:

1行,1个整数，表示查询的加权距离。

输入样例:

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

5
1 2
2 3
1 4
4 5
3 4

输出样例:

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

8

题目分析

首先说一句，这道题的样例很特殊，只有两种情况，一种情况是查询的两个点在二叉树root的两侧，另一种情况是查询的点在二叉树root的同一侧的同一路径上，所以，我只记录输入点的父节点，在第一种情况下一直找到根就能过，非常nice(原谅我偷懒了)。

事实上，应该还有的情况是查询的两个点有一个最近公共祖先，而这个祖先不是二叉树的root。

代码实现如下

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

#define max 100010
int p[max];
long sum;
int main(){
	int n,a,b,maxn=0;
	scanf("%d",&n);
    p[1]=1;
	while(1){
		scanf("%d %d",&a,&b);
		if(p[b])break;
		p[b]=a;
	}
	int t0,t1=a,t2=b;
	t0=a;
    while(t0!=1&&t0!=b)t0=p[t0];
    if(t0==b){while(t1!=b){t1=p[t1];sum+=3;}}
    t0=b;
    while(t0!=1&&t0!=a)t0=p[t0];
    if(t0==a){while(t2!=a){t2=p[t2];sum+=2;}}
    else{
        while(t1!=1){t1=p[t1];sum+=3;}
	    while(t2!=1){t2=p[t2];sum+=2;}
    }
	
	printf("%ld",sum);
	return 0;
}

7-3 修轻轨 (100 分)

长春市有n个交通枢纽，计划在1号枢纽到n号枢纽之间修建一条轻轨。轻轨由多段隧道组成，候选隧道有m段。每段候选隧道只能由一个公司施工，施工天数对各家公司一致。有n家施工公司，每家公司同时最多只能修建一条候选隧道。所有公司可以同时开始施工。请评估：修建这条轻轨最少要多少天。。

输入格式:

第1行，两个整数n和m，用空格分隔，分别表示交通枢纽的数量和候选隧道的数量，1 ≤ n ≤ 100000，1 ≤ m ≤ 200000。

第2行到第m+1行，每行三个整数a、b、c，用空格分隔，表示枢纽a和枢纽b之间可以修建一条双向隧道，施工时间为c天，1 ≤ a, b ≤ n，1 ≤ c ≤ 1000000。

输出格式:

输出一行，包含一个整数，表示最少施工天数。

输入样例:

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

6 6
1 2 4
2 3 4
3 6 7
1 4 2
4 5 5
5 6 6

输出样例:

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

6

题目分析

简单的prim。

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

#define max 100010

vector<pair<int,int> >e[max];

struct cmp{
	bool operator ()(pair<int,int> a,pair<int,int> b){
		return a.second>b.second;
	}
};
int lowcost[max];
int path[max];
int mark[max];
int maxn,l;

priority_queue <pair<int,int>,vector<pair<int,int> >,cmp> q;
void prim(int n){
	int st=1;
	for(int i=1;i<=n;i++){
	lowcost[i]=max;
		}
	for(int i=0;i<e[st].size();i++){
		pair<int,int> vw=e[st][i];
		int v=vw.first;
		int w=vw.second;
		lowcost[v]=w;
		path[v]=st;
		q.push({v,lowcost[v]});
	}
	mark[st]=1;
	while(!q.empty()){
		pair<int,int> ud=q.top();
		q.pop();
		int u=ud.first;
        if(mark[u])continue;
		mark[u]=1;
        if(u==n){
            maxn=0,l=n;
	        while(l!=1){
		        if(lowcost[l]>maxn)maxn=lowcost[l];
		        l=path[l];
	        }
            return ;
        }
		for(int j=0;j<e[u].size();j++){
				pair<int,int> vw=e[u][j];
				int v=vw.first;
				int w=vw.second;
				if(lowcost[v]>w&&!mark[v]){
					lowcost[v]=w;
					path[v]=u;
					q.push({v,lowcost[v]});
				}
			}
	}
	
}
int main(){
	int n,m;
	scanf("%d %d",&n,&m);
	for(int i=0;i<m;i++){
		int a,b,c;
		scanf("%d %d %d",&a,&b,&c);
		e[a].push_back({b,c});
		e[b].push_back({a,c});
        lowcost[a]=max;
        lowcost[b]=max;
	}
	prim(n);
    printf("%d",maxn);
	return 0;
}

7-4 数据结构设计I (100 分)

小唐正在学习数据结构。他尝试应用数据结构理论处理数据。最近，他接到一个任务，要求维护一个动态数据表，并支持如下操作：

1. 插入操作（I）：从表的一端插入一个整数。

2. 删除操作（D）：从表的另一端删除一个整数。

3. 取反操作（R）：把当前表中的所有整数都变成相反数。

4. 取最大值操作（M）：取当前表中的最大值。

   如何高效实现这个动态数据结构呢？

输入格式:

第1行，包含1个整数M，代表操作的个数， 2≤M≤1000000。

第2到M+1行，每行包含1个操作。每个操作以一个字符开头，可以是I、D、R、M。如果是I操作，格式如下：I x, x代表插入的整数，-10000000≤x≤10000000。 。

输出格式:

若干行，每行1个整数，对应M操作的返回值。如果M和D操作时队列为空，忽略对应操作。

输入样例:

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

6
I 6
R
I 2
M
D
M

输出样例:

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

2
2

题目分析

即考察单调队列，设置一个flag标记是否取反，每次遇到取反命令时flag异或1，当有取反指令时(flag=1)，insert操作：插入这个数的相反数，再加入单调队列中，取max操作：取最小的数的相反数。当无取反指令时(flag=0)，正常insert和取max。主要在于维护两个单调队列，一个存区间最小，一个存区间最大。

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

#define max 1000010

int q[max],qmax[max],qmin[max];
int l,r,lmax,lmin,rmax=-1,rmin=-1;

int flag;

void I(int t){
    if(flag)
	    t=-t;
    q[r++]=t;
    while(rmax>=lmax&&q[qmax[rmax]]<=t)rmax--;
        qmax[++rmax]=r-1;
    while(rmin>=lmin&&q[qmin[rmin]]>=t)rmin--;
        qmin[++rmin]=r-1;
	return ;
}
int M(){
    if(flag)
	    return -q[qmin[lmin]];
    else 
        return q[qmax[lmax]];
}
void R(){
	flag^=1;
}
void D(){
	l++;
    while(qmax[lmax]<l&&lmax<=rmax)lmax++;
    while(qmin[lmin]<l&&lmin<=rmin)lmin++;
}
int main(){
	int n,h;
	char ch;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("\n%c",&ch);
		if(ch=='I'){scanf("%d",&h);I(h);}
		else if(ch=='R')R();
		else if(ch=='D'&&l<r)D();
		else if(ch=='M'&&l<r)printf("%d\n",M());
	}
	return 0;
}