CodeForces 380A Sereja and Prefixes

A. 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

两种操作，为一的话，添加一个数，为2的话，对前面长度为l的串进行复制。。显然，复制的长度最长不超过10^5，也就是说，10^5后面的数字一定可以在前面找到的。所以可以记录前10^5的数组，对于后面的数一定可以在前面找到，所以可以记录下每次操作以后的数字串长度，对要找的数字的位置进行二分查找。找到其位置后，如果是属于操作1的，则直接是这个数。如果是操作2的，就继续往前面找。

#include<stdio.h>
#include<string.h>
#define M 100005
int type[M],m,a[M],b[M];
__int64 len[M],pos;
int finds(__int64 pos){
int l=1,r=m,mid;
while(l<r){
mid=(l+r)/2;
if(len[mid]<pos)
l=mid+1;
else r=mid;
}
return l;
}
int solve(__int64 pos)
{
int k=finds(pos);
if(type[k]==1)return a[k];
pos=pos-len[k-1];
pos=pos%a[k];
if(pos==0)pos=a[k];
return solve(pos);
}
int main()
{
int  n,c,i,j;
scanf("%d",&m);
len[0]=0;
for(i=1;i<=m;i++)
{
scanf("%d",&type[i]);
if(type[i]==1){
scanf("%d",&a[i]);
len[i]=len[i-1]+1;
}
else	if(type[i]==2){
scanf("%d%d",&a[i],&b[i]);
len[i]=len[i-1]+a[i]*b[i];
}
}
scanf("%d",&n);
while(n--)
{
scanf("%I64d",&pos);
printf("%d ",solve(pos));

}
printf("\n");
return 0;
}