【CF 698B】Fix a Tree（dfs）

【CF 699D】Fix a Tree（dfs）

D. Fix a Tree

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

A tree is an undirected connected graph without cycles.

Let's consider a rooted undirected tree with n vertices, numbered 1 through n. There are many ways to represent such a tree. One way is to create an array with n integers p1, p2, ..., pn, where pi denotes a parent of vertex i (here, for convenience a root is considered its own parent).

For this rooted tree the array p is [2, 3, 3, 2].

Given a sequence p1, p2, ..., pn, one is able to restore a tree:

1. There must be exactly one index r that pr = r. A vertex r is a root of the tree.
2. For all other n - 1 vertices i, there is an edge between vertex i and vertex pi.

A sequence p1, p2, ..., pn is called valid if the described procedure generates some (any) rooted tree. For example, for n = 3 sequences(1,2,2), (2,3,1) and (2,1,3) are not valid.

You are given a sequence a1, a2, ..., an, not necessarily valid. Your task is to change the minimum number of elements, in order to get a valid sequence. Print the minimum number of changes and an example of a valid sequence after that number of changes. If there are many valid sequences achievable in the minimum number of changes, print any of them.

Input

The first line of the input contains an integer n (2 ≤ n ≤ 200 000) — the number of vertices in the tree.

The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ n).

Output

In the first line print the minimum number of elements to change, in order to get a valid sequence.

In the second line, print any valid sequence possible to get from (a1, a2, ..., an) in the minimum number of changes. If there are many such sequences, any of them will be accepted.

Examples

input

4
2 3 3 4

output

1
2 3 4 4 

input

5
3 2 2 5 3

output

0
3 2 2 5 3 

input

8
2 3 5 4 1 6 6 7

output

2
2 3 7 8 1 6 6 7

Note

In the first sample, it's enough to change one element. In the provided output, a sequence represents a tree rooted in a vertex 4(because p4 = 4), which you can see on the left drawing below. One of other correct solutions would be a sequence 2 3 3 2, representing a tree rooted in vertex 3 (right drawing below). On both drawings, roots are painted red.

In the second sample, the given sequence is already valid.

i到0的距离有多远?就是WA到AC……

0写成i过了present也真是。。。TOT

题目大意:n个点的图，每个点有一个前驱，可知这样有n条边。

如果是树的话，除了根指向自己，其他点都会有前驱。

现在给出的是一个任意的图，这样会出现多棵树，或者树中有环，或者两者都存在的情况。

问至少改变几个前驱能把他变成一棵标准的多叉树（除了根指向自己，其他节点都指向非自己的节点）。

并和输入格式一样，输出1~n的前驱。

由于每个点只有一个前驱。

那么可以想到，每棵树（内部有环的暂且也称为树）有且只会有一个环（要么是根指向自己，要么是成环了，但有且只有一个）。

这样通过搜索，可以搜到每一棵“坏树“上的环，改变的其实也就是环上的点（任意一个即可）

这样把所有环拆开，接到一个根上即可。

如果全是非自环的话，这样是保证了最少改变数量。

如果有一个以上自环的话，其实就可以把它当做最终的树根了，这样可以节省改变次数。

最后……一定要看准下标。。。

代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <queue>
#include <map>
#include <stack>
#include <algorithm>
#include <cmath>
#define LL long long
#define Pr pair<int,int>
#define VI vector<int>

using namespace std;
const int INF = 0x3f3f3f3f;
const double eps = 1e-8;
const int msz = 1e5+1;

struct Edge
{
    int v,next;
};

Edge eg[666666];
bool vis[233333];
int tp;
int head[233333];
int fth[233333];

void Add(int u,int v)
{
    eg[tp].v = v;
    eg[tp].next = head[u];
    head[u] = tp++;
}

int dfs(int u,int pre)
{
    vis[u] = 1;
    int ans = -1;
    int tmp;
    for(int i = head[u]; i != -1; i = eg[i].next)
    {
        if(eg[i].v == pre || eg[i].v == u) continue;
        //printf("%d %d\n",u,eg[i].v);
        if(fth[u] == eg[i].v && fth[eg[i].v] == fth[u]) ans = u;
        if(vis[eg[i].v])
        {
            if(fth[eg[i].v] == u) ans = eg[i].v;
            else ans = u;
        }
        else
        {
            tmp = dfs(eg[i].v,u);
            if(tmp != -1) ans = tmp;
        }
    }

    if(fth[u] == u) ans = u;
    return ans;
}

int main()
{
    int n;

    scanf("%d",&n);

    memset(head,-1,sizeof(head));
    tp = 0;
    for(int i = 1; i <= n; ++i)
    {
        scanf("%d",&fth[i]);
        Add(i,fth[i]);
        Add(fth[i],i);
    }

    int ans = 0;
    int root = -1;
    int to = -1;
    int tmp[233333];

    memset(vis,0,sizeof(vis));
    for(int i = 1; i <= n; ++i)
    {
        if(vis[i]) continue;
        tmp[ans++] = dfs(i,i);
        if(to == -1 && tmp[ans-1] == fth[tmp[ans-1]])
        {
            ans--;
            to = tmp[ans];
        }
    }

    for(int i = 0; i < ans; ++i)
    {
        if(to == -1) fth[tmp[i]] = tmp[0/*i*/];//i到0的距离。。
        else fth[tmp[i]] = to;
    }

    printf("%d\n",ans);
    for(int i = 1; i <= n; ++i)
    {
        if(i != 1) putchar(' ');
        printf("%d",fth[i]);
    }

    return 0;
}