CodeForces #230 div2 C Sereja and Prefixes

题目

C. Sereja and Prefixes

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Sereja loves number sequences very much. That's why he decided to make himself a new one following a certain algorithm.

Sereja takes a blank piece of paper. Then he starts writing out the sequence in m stages. Each time he either adds a new number to the end of the sequence or takes l first elements of the current sequence and adds them c times to the end. More formally, if we represent the current sequence as a1, a2, ..., an, then after we apply the described operation, the sequence transforms into a1, a2, ..., an[, a1, a2, ..., al] (the block in the square brackets must be repeated c times).

A day has passed and Sereja has completed the sequence. He wonders what are the values of some of its elements. Help Sereja.

Input

The first line contains integer m (1 ≤ m ≤ 105) — the number of stages to build a sequence.

Next m lines contain the description of the stages in the order they follow. The first number in the line is a type of stage (1 or 2). Type 1 means adding one number to the end of the sequence, in this case the line contains integer xi (1 ≤ xi ≤ 105) — the number to add. Type 2 means copying a prefix of length li to the end ci times, in this case the line further contains two integers li, ci (1 ≤ li ≤ 105, 1 ≤ ci ≤ 104), li is the length of the prefix, ci is the number of copyings. It is guaranteed that the length of prefix li is never larger than the current length of the sequence.

The next line contains integer n (1 ≤ n ≤ 105) — the number of elements Sereja is interested in. The next line contains the numbers of elements of the final sequence Sereja is interested in. The numbers are given in the strictly increasing order. It is guaranteed that all numbers are strictly larger than zero and do not exceed the length of the resulting sequence. Consider the elements of the final sequence numbered starting from 1 from the beginning to the end of the sequence.

Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.

Output

Print the elements that Sereja is interested in, in the order in which their numbers occur in the input.

Sample test(s)

input

6
1 1
1 2
2 2 1
1 3
2 5 2
1 4
16
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

output

1 2 1 2 3 1 2 1 2 3 1 2 1 2 3 4

作为一个ACM菜鸟的我。。昨晚刚看这道题的时候，咋一看上去，不就是水题一道嘛。。。后面在wa了多次，无意见看到某大牛的博客才看到。。  用通常的方法来吧所需要的那个字符串给存起来，那是绝对做不到的，因为它的长度太长了随随便便都能10^9以上。。。木有办法只有通过不断的缩小查询区间，最后把所要求的那个数给查出来。

用一个len [maxn] 数组存储每次进行操作以后的长度。 对于每一次查询p，用二分查找，找到第一个大于等于p的len[i],其中i是操作数,如果t[i]=1 ,则直接返回a[k]，就成，否则，则要不断的向前查找缩小查询范围。

不多说，下附代码

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstdio>
using namespace std;
typedef unsigned long long ll;
const int maxn=100000+10;
ll len[maxn];
ll a[maxn],b[maxn];
int t[maxn];
ll n,m;
ll find(ll p)
{
	int low=1,high=n;
	while(low<high)
	{
		int mid=(low+high)/2;
		if(p<=len[mid])
		{
			high=mid;
		}
		else
		{
			low=mid+1;
		}
	}
	return low;
}
ll solve(ll p)
{
	int k=find(p);
	if(t[k]==1)
	{
		return a[k];
	}
	p-=len[k-1];
	p%=a[k];
	if(p==0)
	{
		p=a[k];
	}	
	return solve(p);
}
int main()
{
	 while(scanf("%I64d",&n)!=EOF)
	 {
		len[0]=0;
		for(int i=1;i<=n;i++)
		{
			scanf("%d%I64d",&t[i],&a[i]);
			if(t[i]==1)
			{
				len[i]=len[i-1]+1;
			}
			else
			{
				scanf("%I64d",&b[i]);
				len[i]=len[i-1]+a[i]*b[i];
			}
		}
		scanf("%I64d",&m);
		for(int i=1;i<=m;i++)
		{
			if(i!=1)
			{
				printf(" ");
			}
			ll p;
			scanf("%I64d",&p);
			ll ans=solve(p);
			printf("%I64d",ans);
		}
		printf("\n");
 	 }
 	 return 0;
}