其他分享
首页 > 其他分享> > 数据结构第二次上机实验解题报告

数据结构第二次上机实验解题报告

作者:互联网

7-1 数列查询

已知数列的通项公式为:

     f(n) = f(n-1)*11/10,f[1]=10. 

通项从左向右计算,*和/分别表示整数乘法和除法。 现在,要多次查询数列项的值。

输入格式:

第1行,1个整数q,表示查询的次数, 1≤q≤10000. 第2至q+1行,每行1个整数i,表示要查询f(i)的值。

输出格式:

q行,每行1个整数,表示f(i)的值。查询的值都在32位整数范围内。

输入样例:

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

3
1
2
3

输出样例:

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

10
11
12

 作者 谷方明

单位 吉林大学

代码长度限制 16 KB

时间限制 10 ms

内存限制 1 MB

 解法一:

题目中给出了f(n) = f(n-1)*11/10,f[1]=10.这样的递推式子,于是我就想到了用递归来做。但是,如果递归出口只是f[1]的话,肯定无法通过。在递归的过程中,数列中的很多项都已经被计算出来了,应该把它们利用起来,而不是在下一次递归调用中重复计算。因此,应在递归过程中保存f[i]的结果,并可以使用一个标志数组来标明哪些项已经被计算出来。递归时,遇到已经计算出的项,就可以返回,而不是一直到f[1].

代码如下:

int givef(int n)
{
	if(flag[n]==1)return f[n];
	f[n]=givef(n-1)*11/10;
	flag[n]=1;
	return f[n];
}

事实上,并不需要这个标志数组flag,因为这个数列中的每一项都是正整数,只要f[i]>0就能说明第i项已经被计算出来。

int givef(int n)
{
	if(f[n]>0)return f[n];
	f[n]=givef(n-1)*11/10;
	return f[n];
}

整体代码如下:

#include<cstdio>

const int maxn=10000;
int f[maxn]={0};
//int flag[maxn]={0};


int givef(int n)
{
	if(f[n]>0)return f[n];
	f[n]=givef(n-1)*11/10;
	return f[n];
}

int main()
{
    f[1]=10;
	int q,t;
	int i;
	scanf("%d",&q);
	for(i=0;i<q;i++)
	{
		scanf("%d",&t);
		if(i>0)printf("\n");
		printf("%d",givef(t));
	}
	return 0;
}

但是,这个方法并不总是能通过,在pta上通过的频率大约为0.5  .因为函数调用也是有一定的时间代价的,递归函数反映得尤为显著(但是,只要有一次通过了全部样例,就能拿到满分,因此我觉得这是个能用的解法,至少对pta很有用)。

解法二:

如果能够事先算出足够多的项,能够覆盖可能被查询到的范围,那么每次查询的代价都是O(1),效率很高。那么,本题中“足够多的项”是多少项呢?题目中有“查询的值都在32位整数范围内”,这就是一个范围,于是我们自己尝试一下,就会发现,f[202]=195422668  ,   f[203]=-214531794.因此我们只用算出前202项就可以了。

代码如下:

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

int f[205];

int main()
{
	f[1]=10;
	int i;
	for(i=2;i<=202;i++)
	{
		f[i]=f[i-1]*11/10;
	}
	int q,k;
	scanf("%d",&q);
	for(i=0;i<q;i++)
	{
		scanf("%d",&k);
		printf("%d\n",f[k]);
	}
	return 0;
}

这个方法基本上不会超时(也有超时的情况出现)。

7-2 稀疏矩阵之和

矩阵A和B都是稀疏矩阵。请计算矩阵的和A+B.如果A、B不能做和,输出“Illegal!”

输入格式:

矩阵的输入采用三元组表示,先A后B。对每个矩阵:

第1行,3个整数N、M、t,用空格分隔,分别表示矩阵的行数、列数和非0数据项数,10≤N、M≤50000,t≤min(N,M).

第2至t+1行,每行3个整数r、c、v,用空格分隔,表示矩阵r行c列的位置是非0数据项v, v在32位有符号整型范围内。三元组默认按行列排序。

输出格式:

矩阵A+B,采用三元组表示,默认按行列排序,非零项也在32位有符号整型范围内。

输入样例:

10 10 3
2 2 2
5 5 5
10 10 20
10 10 2
2 2 1
6 6 6

输出样例:

10 10 4
2 2 3
5 5 5
6 6 6
10 10 20

 三元组的写法:

struct Triple{
	int value;//元素值
	int row,col;//下标值
};//三元组结点定义

struct TSMatrix{
	Triple data[MAXSIZE+1];//data[0]不用
	int mu,nu,tu;//行数,列数,非零元素个数
};//三元组顺序表定义

两个矩阵相加:

void AddMastrix(const TSMatrix& M,const TSMatrix& T,TSMatrix &Q){
	int index_a,index_b,i=1,j=1,k=1;
	Q.mu=M.mu; Q.nu=M.nu;
	while (i<=M.tu&&j<=T.tu){
		//按行优先遍历矩阵的非零元
		index_a=(M.data[i].row-1)*(M.nu)+M.data[i].col;
		index_b=(T.data[j].row-1)*(T.nu)+T.data[j].col;
		if(index_a<index_b){     //M的非零元素下标值小于T的 直接令Q的对应元素等于M中元素
			Q.data[k]=M.data[i];
			i++;
			k++;
		}
		else if(index_a>index_b){
			Q.data[k]=T.data[j];
			j++;
			k++;
		}
		else if(index_a==index_b){
			if((M.data[i].value+T.data[j].value)!=0){//相加为零的话,就不应该放入三元组表中 
				Q.data[k]=M.data[i];
				Q.data[k].value=M.data[i].value+T.data[j].value;
				k++;
			}
			++i;
			++j;
		}
	}
	//当M和T有一个遍历结束时,复制另一个的剩余元素进Q
	for(;i<=M.tu;++i){
		Q.data[k]=M.data[i];
		k++;
	}
	for(;j<=T.tu;++j)
		Q.data[k++]=T.data[j];
	Q.tu=k-1;
}

这种方法的前提,是原来两个三元组表就是按行优先排好序的。这种方法类似于把两个有序的序列合成一个有序的序列。

7-3 文字编辑

一篇文章由n个汉字构成,汉字从前到后依次编号为1,2,……,n。 有四种操作:

A i j表示把编号为i的汉字移动编号为j的汉字之前;

B i j表示把编号为i的汉字移动编号为j的汉字之后;

Q 0 i为询问编号为i的汉字之前的汉字的编号;

Q 1 i为询问编号为i的汉字之后的汉字的编号。

规定:1号汉字之前是n号汉字,n号汉字之后是1号汉字。

输入格式:

第1行,1个整数T,表示有T组测试数据, 1≤T≤9999.

随后的每一组测试数据中,第1行两个整数n和m,用空格分隔,分别代表汉字数和操作数,2≤n≤9999,1≤m≤9999;第2至m+1行,每行包含3个常量s、i和j,用空格分隔,s代表操作的类型,若s为A或B,则i和j表示汉字的编号,若s为Q,i代表0或1,j代表汉字的编号。

输出格式:

若干行,每行1个整数,对应每个询问的结果汉字编号。

输入样例:

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

1 
9999 4 
B 1 2  
A 3 9999
Q 1 1
Q 0 3

输出样例:

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

4
9998

这是一道模拟题。对于每一个汉字,需要保存的是它自己的编号,它前一个汉字的编号,它后一个汉字的编号。我用了一个结构体数组,下标表示此汉字的编号,两个成员分别表示前一个汉字的编号和后一个汉字的编号 :

struct node{
	int fr;
	int af;
}text[10000];

这其实就成了一个静态双向链表。(个人觉得,这一点没有必要被想到)

然后,每个操作都是对相关汉字的成员变量进行修改或输出。

整体代码如下:

#include<cstdio>

struct node{
	int fr;
	//int data;
	int af;
}text[10000];

int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		int n,m;
		int i;
		scanf("%d%d",&n,&m);
		for(i=1;i<=n;i++)
		{
			text[i].fr=i-1;
			//text[i].data=i;
			text[i].af=i+1;
		}
		text[1].fr=9999;
		text[n].af=1;
		char op;
		int ii,jj;
		for(i=1;i<=m;i++)
		{
			op='\0';
			while(op!='B'&&op!='A'&&op!='Q')op=getchar();//解决回车换行符造成的干扰的办法
			scanf("%d%d",&ii,&jj);
			if(op=='A')
			{
				text[text[ii].fr].af=text[ii].af;
				text[text[ii].af].fr=text[ii].fr;
				text[text[jj].fr].af=ii;
				text[ii].fr=text[jj].fr;
				text[ii].af=jj;
				text[jj].fr=ii;
			}
			else if(op=='B')
			{
				text[text[ii].fr].af=text[ii].af;
				text[text[ii].af].fr=text[ii].fr;
				text[text[jj].af].fr=ii;
				text[ii].af=text[jj].af;
				text[ii].fr=jj;
				text[jj].af=ii;
			}
			else if(op=='Q')
			{
				if(ii==0) printf("%d\n",text[jj].fr);
				else printf("%d\n",text[jj].af);
			}
		}
	}
	return 0;
}

当时我遇到了scanf和getchar()被'\n'干扰的问题,于是我用这种办法回避这个问题:

op='\0';//只要不是'B','A','Q'就行
while(op!='B'&&op!='A'&&op!='Q')op=getchar();//解决回车换行符造成的干扰的办法

 7-4 幸福指数

人生中哪段时间最幸福?幸福指数可能会帮你发现。幸福指数要求:对自己每天的生活赋予一个幸福值,幸福值越大表示越幸福。一段时间的幸福指数就是:这段时间的幸福值的和乘以这段时间的幸福值的最小值。幸福指数最大的那段时间,可能就是人生中最幸福的时光。

输入格式:

第1行,1个整数n,, 1≤n≤100000,表示要考察的天数。

第2行,n个整数Hi,用空格分隔,Hi表示第i天的幸福值,0≤n≤1000000。

输出格式:

第1行,1个整数,表示最大幸福指数。

第2行,2个整数l和r,用空格分隔,表示最大幸福指数对应的区间[l,r]。如果有多个这样的区间,输出最长最左区间。

输入样例:

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

7
6 4 5 1 4 5 6

输出样例:

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

60
1 3

这个题上机时我不会,用暴力法拿了50分。现在看dalao们的题解知道了方法,就复述一遍吧。 

以每一天的幸福值作为最小值,寻找这一天所属的最大幸福指数对应的区间。确定这个区间的方法,是找出每一个数的左边第一个小于它的和右边第一个小于它的数,如果找不到,就该区间就会延伸至整个序列的首端或末端。于是,可以看出单调栈的应用。我们可以从左到右找一遍每个数左边第一个比它小的数所在的位置,再从右到左找一遍每个数右边第一个比它小的数所在的位置,并存储起来。

struct limit{
	int left;
	int right;
}lr[100010];


int lst[100010];
int top1=-1;
int rst[100010];
int top2=-1;
int h[100010];


    for(i=1;i<=n;i++)
	{
		while(top1!=-1&&h[lst[top1]]>=h[i])top1--;
		if(top1!=-1)
		    lr[i].left=lst[top1]+1;
		else
		    lr[i].left=1;
		lst[++top1]=i;
	}
	for(i=n;i>=1;i--)
	{
		while(top2!=-1&&h[rst[top2]]>=h[i])top2--;
		if(top2!=-1)
		    lr[i].right=rst[top2]-1;
		else
		    lr[i].right=n;
		rst[++top2]=i;
	}

 接下来,就要计算每个区间的幸福指数,并找出符合要求的区间。计算一段区间的幸福值之和仍然采用前缀和作差的办法,因此在输入时要算好前缀和。

整体代码如下:

#include<bits/stdc++.h>

long long sum[100010];
struct limit{
	int left;
	int right;
}lr[100010];

int lst[100010];
int top1=-1;
int rst[100010];
int top2=-1;
int h[100010];

int main()
{
	int i;
	int n;
	scanf("%d",&n);
	for(i=1;i<=n;i++)
	{
		scanf("%d",&h[i]);
		sum[i]=h[i]+sum[i-1];
	}
	for(i=1;i<=n;i++)
	{
		while(top1!=-1&&h[lst[top1]]>=h[i])top1--;
		if(top1!=-1)
		    lr[i].left=lst[top1]+1;
		else
		    lr[i].left=1;
		lst[++top1]=i;
	}
	for(i=n;i>=1;i--)
	{
		while(top2!=-1&&h[rst[top2]]>=h[i])top2--;
		if(top2!=-1)
		    lr[i].right=rst[top2]-1;
		else
		    lr[i].right=n;
		rst[++top2]=i;
	}
	long long max=-10000000;
	int posl=0,posr=0;
	long long tmp;
	for(i=1;i<=n;i++)
	{
		tmp=(sum[lr[i].right]-sum[lr[i].left-1])*h[i];
		if(max<tmp||(max==tmp&&posr-posl<lr[i].right-lr[i].left))
		{
			max=tmp;
			posl=lr[i].left;
			posr=lr[i].right;
		}
	}
	printf("%lld\n%d %d",max,posl,posr);
	return 0;
}

 由于有多个区间都取得最大幸福指数时,要取最长最左区间,因此有if(max<tmp||(max==tmp&&posr-posl<lr[i].right-lr[i].left))。不能是posr-posl<=lr[i].right-lr[i].left,因为在等长的情况下要求最左。

 

标签:10,上机,int,top2,汉字,解题,编号,数据结构,data
来源: https://blog.csdn.net/m0_53608476/article/details/116882872