标签：10 上机 int top2 汉字 解题 编号 数据结构 data

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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。