#include<bits/stdc++.h>

using namespace std;

#define nl '\n'

void Solve(){
	int n;
	cin>>n;
	vector<int> v(n);
	vector<bool> calledOut(n + 1);
	for(int i = 0; i < n; i++){
		cin>>v[i];
	}
	int called = 0;
	for(int i = 0; i < n; i++){
		if(!calledOut[i + 1]){
			calledOut[v[i]] = true;
			called++;
		}
	}
	cout<<n - called<<nl;
	for(int i = 1; i <= n; i++){
		if(!calledOut[i]) cout<<i<<" ";
	}
	cout<<nl;

}
int main(){
	ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	int T = 1;
	//cin>>T;
	while(T--){
		Solve();
	}
}

vt<vt<int>> G;
vt<int> vis;

void dfs(int u, int p = -1) {
  if(vis[u])
    return;
  vis[u] = 1;
  for(auto v: G[u]) {
    if(v == p)
      continue;
    dfs(v, u);
  }
}

void solve() {
  int n, m;
  cin >> n >> m;

  G = vt<vt<int>>(2 * n);
  vis = vt<int>(2 * n);

  for(int i=0; i<n; i++) {
    int b = 2 * i, r = 2 * i + 1;
    G[b].pb(r);
    G[r].pb(b);
  }

  for(int i=0; i<m; i++) {
    int a, c;
    char b, d;
    cin >> a >> b >> c >> d, a--, c--;
    a = a * 2 + (b == 'R');
    c = c * 2 + (d == 'R');

    G[a].pb(c);
    G[c].pb(a);
  }

  int ans1 = 0, ans2 = 0;

  for(int i=0; i<n; i++) {
    int b = 2 * i, r = 2 * i + 1;
    if(vis[b] || vis[r])
      continue;

    if(!vis[r])
      swap(r, b);

    dfs(b, r);
    if(vis[r])
      ans1++;
    else {
      dfs(r, b);
      ans2++;
    }

  }
  cout << ans1 << " " << ans2 << en;
}

A: just output $$$S_{i\oplus 1}$$$ for all $$$i$$$

B: For all $$$i$$$, do $$$X_{X_{i}}=X_i$$$. Now the cells that have to call itself will automatically "do nothing". After we finish, count and enumerate indices where $$$X_i \neq i$$$.

C: Just backtracking lol

D: Just union-find lol

E: I knew this was some matrix exponentiation task but I was too lazy so I just copy pasted a Reeds-Sloane template

G: Mo's. Update using the fact that each element $$$e$$$ with amount $$$v$$$ in the interval contributes $$$v \choose 3$$$ to the answer.

idea was to do a dsu and count the number of cycles and remove that number from total groups to find other number

n,m=map(int,input().split())
parent=[i for i in range(n+1)]
def find(x):
    st=[]
    while parent[x]!=x:
        st.append(x)
        x=parent[x]
    while st:
        parent[st.pop()]=x
    return x
ans=0
for _ in range(m):
    e=[el for el in input().split()]
    l=int(e[0])
    r=int(e[2])
    pl=find(l)
    pr=find(r)
    if pl==pr:
        ans+=1
    else:
        parent[pl]=pr
s=set()
for i in range(1,n+1):
    find(i)
for el in parent[1:]:
    s.add(el)
print(ans,len(s)-ans)

bool good(ll x, ll b){
    ll cur = 1;
    while(x){
        ll next = cur*b;
        if(x==cur) return 1;
        if(cur>x) return 0;
        if(x%next==0){
            cur = next;
            continue;
        }
        x-=cur;
        if(x%next==0){
            cur = next;
            continue;
        }
        return 0;
    }
    return 1;
}