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