Codeforces Gym100425 D. Toll Road

D. Toll Road

time limit per test

1 second

memory limit per test

128 megabytes

input

standard input

output

standard output

Exactly N years ago, a new highway between two major cities was built. The highway runs from west to east. It was planned as one big segment of a toll road. However, new highway was not popular: drivers still used free roads.

After analyzing the situation, the administration decided to perform a marketing trick to increase the popularity of the new highway.

The highway was divided into segments. Initially, there was only one segment. Every odd year, each of the existing segments was divided into two new segments with lengths divided as X: Y. This means that the length of the western segment relates to the length of the eastern segment as X relates to Y. Every even year, each of the existing segments was also divided into two new segments, but this time, the ratio was Y: X. After each division, the first of the two resulting segments was declared a free road and the second one a toll road. Each year, the segments are numbered from 1 from west to east. For simplicity, X and Y are positive integers which sum up to exactly 100.

As a result, the administration was able to significantly increase the income: the drivers started to drive on free segments and did not dare to turn away at the sight of the next toll segment. But after N years, the plan of the highway became so complex that it is now hard to calculate the exact lengths of the segments.

Knowing the total length of the highway P, one can calculate the length L_k of the segment with number k using the formula

L_k = P × (X / 100)^A_k × (Y / 100)^B_k for some integers A_k and B_k. Here, A_k is the number of years in which, during the division, this segment was in the part proportional to X, and B_k is the number of years when it was in the part proportional to Y.

You need to answer to the queries containing numbers K_i of segments. To answer each query, you must print the values of A_ki and B_ki for the corresponding segment.

Input

The first line of the input contains three integers: the number of years N (1 ≤ N ≤ 10¹⁸) that have elapsed since the highway was built, followed by the percentages X and Y (1 ≤ X, Y ≤ 99, X + Y = 100) used each year to divide the segments.

The second line contains one integer: the number of queries Q (1 ≤ Q ≤ 10⁴).

The following Q lines contain queries. Each query is an integer K_i (1 ≤ K_i ≤ 10¹⁸), the number of some segment. It is guaranteed that the segment with such number exists.

Output

For each query, print two integers A_ki and B_ki on a separate line.

Sample test(s)

Input

3 25 75 4
1
3
5
8

Output

2 1
3 0
1 2
1 2

题意

一条公路，从第一年开始，每到奇数年把公路的每一段按照比例$A:B$分成两段，每到偶数年按照比例$B:A$分成两段，过了$N$年，第$k$段的长度为$L_k = P × (\frac X { 100})^{A_k} × (\frac Y{ 100})^{B_k}$，输入$k$，询问$A_k,B_k$

题解

数据看起来很吓人。。实际上还是二分(又是二分。。)，分割的过程可以表示成一个完全二叉树，边权是分割的比例，$N$年后公路一共有$2^N$段，然后$2^{60}=1152921504606846976$。。超过了询问的最大范围。。。当$N\gt60$,考虑最左边的路径，发现权值是$A,B$交替出现的，于是初始化$A=(N-60)/2,B=(N-60)/2$,如果$(N-60)$是奇数，$A+1$，令$N=60$。然后又可以二分啦！在二分的过程中更新$ansa$和$ansb$的值就好。

代码

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#define fout freopen("out.txt","w",stdout)
#define fin freopen("in.txt","r",stdin)

using namespace std;

long long N;
int X,Y,Q;
long long K,ans[2],A=0,B=0;
int mark=0;
void Find(long long x,int flag)
{
    long long m,l=1,r=N;
    m=(l+r)/2;
    while(1)
    {
        if(x<=m)
        {
            r=m;
            ans[flag]++;
            flag=!flag;
        }
        else
        {
            l=m+1;
            flag=!flag;
            ans[flag]++;
        }
        if(l==m||l==r)
            break;
        m=(l+r)/2;
    }
}
int main()
{
    scanf("%I64d%d%d%d",&N,&X,&Y,&Q);
    if(N>60)
    {
        A=B=(N-60)/2;
        if((N-60)&1)
        {
            A++;
            mark=1;
        }
        N=60;
    }
    N=1LL<<N;
    for(int i=0;i<Q;i++)
    {
        scanf("%I64d",&K);
        ans[0]=ans[1]=0;
        Find(K,mark);
        printf("%I64d %I64d\n",ans[0]+A,ans[1]+B);
    }
    return 0;
}