Books Exchange (hard version) CodeForces - 1249B2

Time limit

1000 ms

Memory limit

262144 kB     

Source

Codeforces Round #595 (Div. 3)

 

The only difference between easy and hard versions is constraints.

There are nn kids, each of them is reading a unique book. At the end of any day, the ii -th kid will give his book to the pipi -th kid (in case of i=pii=pi the kid will give his book to himself). It is guaranteed that all values of pipi are distinct integers from 11 to nn (i.e. pp is a permutation). The sequence pp doesn't change from day to day, it is fixed.

For example, if n=6n=6 and p=[4,6,1,3,5,2]p=[4,6,1,3,5,2] then at the end of the first day the book of the 11 -st kid will belong to the 44 -th kid, the 22 -nd kid will belong to the 66 -th kid and so on. At the end of the second day the book of the 11 -st kid will belong to the 33 -th kid, the 22 -nd kid will belong to the 22 -th kid and so on.

Your task is to determine the number of the day the book of the ii -th child is returned back to him for the first time for every ii from 11 to nn .

Consider the following example: p=[5,1,2,4,3]p=[5,1,2,4,3] . The book of the 11 -st kid will be passed to the following kids:

• after the 11 -st day it will belong to the 55 -th kid,
• after the 22 -nd day it will belong to the 33 -rd kid,
• after the 33 -rd day it will belong to the 22 -nd kid,
• after the 44 -th day it will belong to the 11 -st kid.

So after the fourth day, the book of the first kid will return to its owner. The book of the fourth kid will return to him for the first time after exactly one day.

You have to answer qq independent queries.

Input

The first line of the input contains one integer qq (1≤q≤10001≤q≤1000 ) — the number of queries. Then qq queries follow.

The first line of the query contains one integer nn (1≤n≤2⋅1051≤n≤2⋅105 ) — the number of kids in the query. The second line of the query contains nn integers p1,p2,…,pnp1,p2,…,pn (1≤pi≤n1≤pi≤n , all pipi are distinct, i.e. pp is a permutation), where pipi is the kid which will get the book of the ii -th kid.

It is guaranteed that ∑n≤2⋅105∑n≤2⋅105 (sum of nn over all queries does not exceed 2⋅1052⋅105 ).

Output

For each query, print the answer on it: nn integers a1,a2,…,ana1,a2,…,an , where aiai is the number of the day the book of the ii -th child is returned back to him for the first time in this query.

Example

 

Input

6
5
1 2 3 4 5
3
2 3 1
6
4 6 2 1 5 3
1
1
4
3 4 1 2
5
5 1 2 4 3

Output

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

题意与思路：

按着每个位置给的数跳到下一个位置，直到找到与原来的数一样，就相当于循环 到本身需要几次；

例如第二组数据：

4

3  4  1  2

第1个位置的值是3，跳到第3个位置（3->1）-->变化1次 ;再跳到第1个位置（1->3）-->变化2次；回到了最初位置；所以是2次；

第二个位置的值是4；到第4个位置（4->2)-->变化一次；再到第2个位置（2->4)-->变化2次；回到了最初位置共2次；

依次类推；

对于思路：

因为这个是循环当前值跳到相应位置形成自环需要的转换次数；这里我用的是队列，

不断去进入队列，直到找到本身也就是形成自环的时候结束，然后开数组存队列大小即中间转换的次数；

提上给的数是不会重复的所以不用担心最小，一直往下进队列就可以了。

代码如下：

#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;
int t,n;
int a[220000],b[220000];
int main()
{
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        memset(b,0,sizeof(b));
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        queue<int>q;///利用的队列
        for(int i=1;i<=n;i++)
        {
            if(b[i])
                continue;
            int m=i;
            do
            {
                q.push(m);
                m=a[m];
            }while(m!=i);
            int ans=q.size();//次数
            while(!q.empty())
            {
                b[q.front()]=ans;
                q.pop();
            }
        }
        for(int i=1;i<=n;i++)
        {
            if(i==n)
                printf("%d\n",b[i]);
            else
                printf("%d ",b[i]);
        }
    }
    return 0;
}