Codeforces Round #614 (Div. 2) D. Aroma's Search

http://codeforces.com/contest/1293/problem/D

 

题意：

二维平面上有若干个点，第i个点的坐标(xi,yi)满足xi=x_i-1*ax+bx,yi=y_y-1*ay+by

已知 ax,bx,ay,by,x0,y0 以及初始位置(xs,ys)

每秒钟可以往上下左右走1个单位

问在t秒内最多可以走到多少个点

 

虽然数据很大，但点数不会很多

因为ax，ay 大于等于2，所以在t秒内能到的点不超过log2(t)个

这些点可以预处理出来

因为x,y的坐标都满足一个一次函数，所以走到的点一定是一个连续的区间，走的同方向的一段花费的时间可以直接用最后一个点的坐标减去第一个点的坐标

假设是[l,r]，即走到了预处理出的第l个点到第r个点

若先去的第z个点，z∈[l,r]

令d(i,j)=|xi-xj|+|yi-yj|

那么花费的时间等于 d(s,z)+min{ d(l,z),d(r,z) } + d(l,r)

时间复杂度 log2(t)^3

 

优化：

z要么等于l，要么等于r

证明（以x坐标为例，y坐标同理）：

 

若xs<=xl，则z=l

若xs>=xr，则z=r

若xl<xs<xr，所需时间为 d(s,z)+min{ d(l,z),d(r,z) } + d(l,r) ,而 d(s,z)+min{ d(l,z),d(r,z) } = min{ d(l,s),d(r,s)} ，所以所需时间为 min{ d(l,s),d(r,s)} + d(l,r)

时间复杂度 log2(t)^2

 

#include<vector>
#include<iostream>
#include<algorithm>

using namespace std;

typedef long long LL; 
typedef pair<LL,LL> pr;

vector<pr>v;

int main()
{
    LL x0,y0,ax,ay,bx,by,xs,ys,t;
    cin>>x0>>y0>>ax>>ay>>bx>>by>>xs>>ys>>t;
    v.push_back(pr(x0,y0));
    while(1)
    {
        x0=x0*ax+bx;
        y0=y0*ay+by;
        if(x0-xs+y0-ys<=t) v.push_back(pr(x0,y0));
        else break; 
    }
    int n=v.size(),ans=0;
    LL len1,len2;
    for(int i=0;i<n;++i)
    {
        len1=abs(v[i].first-xs)+abs(v[i].second-ys);
        for(int j=i;j<n;++j)
        {
            len2=abs(v[j].first-xs)+abs(v[j].second-ys);
            if(min(len1,len2)+v[j].first-v[i].first+v[j].second-v[i].second<=t) ans=max(ans,j-i+1);
            else break;
        }
    }
    cout<<ans;
    return 0;
}

 

D. Aroma's Search

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

THE SxPLAY & KIVΛ - 漂流

KIVΛ & Nikki Simmons - Perspectives

With a new body, our idol Aroma White (or should we call her Kaori Minamiya?) begins to uncover her lost past through the OS space.

The space can be considered a 2D plane, with an infinite number of data nodes, indexed from 00 , with their coordinates defined as follows:

• The coordinates of the 00 -th node is (x0,y0)(x0,y0)
• For i>0i>0 , the coordinates of ii -th node is (ax⋅xi−1+bx,ay⋅yi−1+by)(ax⋅xi−1+bx,ay⋅yi−1+by)

Initially Aroma stands at the point (xs,ys)(xs,ys) . She can stay in OS space for at most tt seconds, because after this time she has to warp back to the real world. She doesn't need to return to the entry point (xs,ys)(xs,ys) to warp home.

While within the OS space, Aroma can do the following actions:

• From the point (x,y)(x,y) , Aroma can move to one of the following points: (x−1,y)(x−1,y) , (x+1,y)(x+1,y) , (x,y−1)(x,y−1) or (x,y+1)(x,y+1) . This action requires 11 second.
• If there is a data node at where Aroma is staying, she can collect it. We can assume this action costs 00 seconds. Of course, each data node can be collected at most once.

Aroma wants to collect as many data as possible before warping back. Can you help her in calculating the maximum number of data nodes she could collect within tt seconds?

Input

The first line contains integers x0x0 , y0y0 , axax , ayay , bxbx , byby (1≤x0,y0≤10161≤x0,y0≤1016 , 2≤ax,ay≤1002≤ax,ay≤100 , 0≤bx,by≤10160≤bx,by≤1016 ), which define the coordinates of the data nodes.

The second line contains integers xsxs , ysys , tt (1≤xs,ys,t≤10161≤xs,ys,t≤1016 ) – the initial Aroma's coordinates and the amount of time available.

Output

Print a single integer — the maximum number of data nodes Aroma can collect within tt seconds.

Examples

Input

Copy

1 1 2 3 1 0
2 4 20

Output

Copy

3

Input

Copy

1 1 2 3 1 0
15 27 26

Output

Copy

2

Input

Copy

1 1 2 3 1 0
2 2 1

Output

Copy

0

Note

In all three examples, the coordinates of the first 55 data nodes are (1,1)(1,1) , (3,3)(3,3) , (7,9)(7,9) , (15,27)(15,27) and (31,81)(31,81) (remember that nodes are numbered from 00 ).

In the first example, the optimal route to collect 33 nodes is as follows:

• Go to the coordinates (3,3)(3,3) and collect the 11 -st node. This takes |3−2|+|3−4|=2|3−2|+|3−4|=2 seconds.
• Go to the coordinates (1,1)(1,1) and collect the 00 -th node. This takes |1−3|+|1−3|=4|1−3|+|1−3|=4 seconds.
• Go to the coordinates (7,9)(7,9) and collect the 22 -nd node. This takes |7−1|+|9−1|=14|7−1|+|9−1|=14 seconds.

In the second example, the optimal route to collect 22 nodes is as follows:

• Collect the 33 -rd node. This requires no seconds.
• Go to the coordinates (7,9)(7,9) and collect the 22 -th node. This takes |15−7|+|27−9|=26|15−7|+|27−9|=26 seconds.

In the third example, Aroma can't collect any nodes. She should have taken proper rest instead of rushing into the OS space like that.