8VC Venture Cup 2017 - Elimination Round D. PolandBall and Polygon【思维+树状数组】好题

D. PolandBall and Polygon

time limit per test

4 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

PolandBall has such a convex polygon with n veritces that no three of its diagonals intersect at the same point. PolandBall decided to improve it and draw some red segments.

He chose a number k such that gcd(n, k) = 1. Vertices of the polygon are numbered from 1 to n in a clockwise way. PolandBall repeats the following process n times, starting from the vertex 1:

Assume you've ended last operation in vertex x (consider x = 1 if it is the first operation). Draw a new segment from vertex x to k-th next vertex in clockwise direction. This is a vertex x + k or x + k - n depending on which of these is a valid index of polygon's vertex.

Your task is to calculate number of polygon's sections after each drawing. A section is a clear area inside the polygon bounded with drawn diagonals or the polygon's sides.

Input

There are only two numbers in the input: n and k (5 ≤ n ≤ 10⁶, 2 ≤ k ≤ n - 2, gcd(n, k) = 1).

Output

You should print n values separated by spaces. The i-th value should represent number of polygon's sections after drawing first i lines.

Examples

Input

5 2

Output

2 3 5 8 11 

Input

10 3

Output

2 3 4 6 9 12 16 21 26 31 

Note

The greatest common divisor (gcd) of two integers a and b is the largest positive integer that divides both a and b without a remainder.

For the first sample testcase, you should output "2 3 5 8 11". Pictures below correspond to situations after drawing lines.

题目大意：

给你一个N多边形，从1开始进行连线，每次和+k之后的点进行相连（now+k如果大于了n，那么就是now+k-n）。一共连线N次，问每次连线结束后，会分成了多少小区域；

思路：

1、首先对于下述思路引入几个设定：我们设定d【i】表示进行到第i次连线之前第i个点所连接的边的个数。

设定劣弧表示，对于一个弦所将圆分成两部分中的较短圆弧。

2、观察样例1的图示。

假设我们现在所有点都在一个圆上的话，

很显然增加的答案就在弦的劣弧部分增加出来的。

那么对应连线的劣弧上的所有点都没有被连过的话，显然答案就是之前的答案加一（只增加了一个区域）。

对应连线的劣弧上的某个点i一共被连了一次的话，显然答案就是之前的答案加2（穿过点i连出的线一次，将增加的区域一分为二）。

对应连线的劣弧上的某个点i一共被连了两次的话，显然答案就是之前的答案加3（穿过点i连出的线两次，将增加的区域一分为三）。

那么最终其实就是：

每次连边之后的结果就是之前的结果+连线两点所组成劣弧上的所有点（抛出去连线的这两个点）d【i】的和+1。

3、那么问题就变成了单点更新，区间求和的问题上来了。

那么接下来只要维护一个树状数组（或者线段树）来O(LogN)查询即可。

4、注意两点，如果k>n/2的时候，可能因为代码实现问题，所带来不对的结果，那么其实如果k>n/2的时候，我们可以让k=k-n/2，让其反过去走（顺时针连线变成逆时针的感觉）。

另外结果比较大，需要LL的地方不要忘记。

Ac代码：

#include<stdio.h>
#include<string.h>
using namespace std;
#define ll __int64
int tree[1000400];
ll ans[1000400];
int n;
int lowbit(int x)
{
    return x&(-x);
}
int sum(int x)
{
    int sum=0;
    while(x>0)
    {
        sum+=tree[x];
        x-=lowbit(x);
    }
    return sum;
}
void add(int x,int c)
{
    while(x<=n)
    {
        tree[x]+=c;
        x+=lowbit(x);
    }
}
int main()
{
    int k;
    while(~scanf("%d%d",&n,&k))
    {
        if(k>n/2)
        {
            k=n-k;
        }
        memset(tree,0,sizeof(tree));
        memset(ans,0,sizeof(ans));
        int tmp=n-1;
        ll output=2;
        int now=1+k;
        add(1,1);
        add(now,1);
        int contz=0;
        ans[contz++]=2;
        while(tmp--)
        {
            int pre=now;
            now+=k;
            if(now>n)now-=n;
            if(now>pre)
            {
                output+=sum(now-1)-sum(pre)+1;
            }
            else
            {
                output+=sum(n)-sum(pre)+sum(now-1)+1;
            }
            add(pre,1);
            add(now,1);
            ans[contz++]=output;
        }
        for(int i=0;i<contz;i++)
        {
            printf("%I64d ",ans[i]);
        }
        printf("\n");
    }
}