3
2 1 1
 6
6 2 6 2 4 2
 2
1 2
 8
2 1 2 2 6 5 6 6
 18
2 3 4 5 2 7 8 9 10 7 11 12 14 15 13 17 18 18
 7
1 2 3 4 5 6 7
 7
4 3 2 6 3 5 2
 7
7 5 3 1 2 1 5
 7
1 6 4 4 5 6 7

1
2 2 1  0
6 2 6 2 4 2  1 
1 1 
 2 
2 2 2 2 6 2 6 6 
 5 
2 3 4 5 11 7 8 9 10 11 11 11 14 15 11 17 18 11 
 6 
1 1 1 1 1 1 1 
 1
4 3 3 6 3 5 2  1
7 5 3 1 3 1 5  4 
1 6 4 1 1 1 1 

import java.util.*;
import java.io.*;

public class CF698B{ 
  public static int parent[], arr[];
  public static void main(String[] args)throws Exception {
    InputReader in = new InputReader(System.in);
    PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
    int n = in.nextInt();
    Node[] comp = new Node[n+1];
   
    parent = new int[n+1];
    arr = new int[n+1];
    for(int i = 1; i <= n; i++){
      arr[i] = in.nextInt();
      parent[i] = i;
      comp[i] = new Node();
    }
    
    for(int i = 1; i <= n; i++){
      int u = find(i), v = find(arr[i]);
      if(i == arr[i]){
        comp[u].root = i;
      }
      else if(u == v){
        comp[u].cycle = i;
      }
      parent[v] = u;
    }
    
//    int cnt = 0;  
//    for(int i = 1; i <= n; i++){
//      if(find(i) == i) cnt++;
//    }
    
    ArrayList<Integer> roots = new ArrayList<Integer>();
    ArrayList<Node> list = new ArrayList<Node>();
    for(int i = 1; i <= n; i++){
      if(comp[i].root != -1 || comp[i].cycle != -1){
        list.add(comp[i]);
      }
      if(comp[i].root != -1){
        roots.add(comp[i].root);
      }
    }
    
    
    int cnt = 0;
    for(Node cmp : list){
      if(cmp.cycle != -1){
        if(roots.size() > 0) arr[cmp.cycle] = roots.get(0);
        else arr[cmp.cycle] = 1;
        cnt++;
      }
      else if(cmp.root != -1){
        int x = arr[cmp.root];
        if(roots.size() > 0)arr[cmp.root] = roots.get(0);
        else arr[cmp.root] = 1;
        if(roots.size() == 0 || roots.get(0) != x) cnt++;
      }
    }
    
    pw.println(cnt);
    for(int i = 1; i <= n; i++){
      pw.print(arr[i]+" ");
    }
    pw.println();
    
    
    
    pw.close();
  }
  
  static int find(int i) {
    int p = parent[i];
    if (i == p) return i;
    return parent[i] = find(p);
  }
  
  static class Node{
    public int root = -1, cycle = -1;
    //public ArrayList<Integer> list;
    public String toString(){
      return root+" "+cycle;
    }
  }
  
  static class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;
    
    public InputReader(InputStream stream) {
      reader = new BufferedReader(new InputStreamReader(stream));
      tokenizer = null;
    }
    
    public String next()throws Exception {
      while (tokenizer == null || !tokenizer.hasMoreTokens())
        tokenizer = new StringTokenizer(reader.readLine());
      return tokenizer.nextToken();
    }
    
    public String nextLine()throws Exception {
      String line = null;
      tokenizer = null;
      line =  reader.readLine();
      return line;
    }
    
    public int nextInt()throws Exception {
      return Integer.parseInt(next());
    }
    
    public double nextDouble() throws Exception{
      return Double.parseDouble(next());
    }
    
    public long nextLong()throws Exception {
      return Long.parseLong(next());
    }
    
  }
}