// Original C++ solution (slower):
#include <bits/stdc++.h>

//#pragma GCC optimize("Ofast")



#define fi first

#define se second



const int N = 100100;



using namespace std;



struct edge{

    int a,b,c,flow;

};

const int MAXN = 200200;

const int inf_int = 1e9;

struct Flow{

    vector<int> g[MAXN];

    vector<edge> e;

    inline int add_edge(int a,int b,int c){

        edge e1 = {a,b,c,0};

        edge e2 = {b,a,0,0};

        int id = e.size();

        g[a].push_back(id);

        e.push_back(e1);

        g[b].push_back(id+1);

        e.push_back(e2);

        return id;

    }



    int s,t,n;

    int ptr[MAXN],dis[MAXN],q[MAXN];

    void init(int S,int T,int N){

        s = S;

        t = T;

        n = N;

    }





    bool bfs(){

        fill(dis,dis+n,inf_int);

        dis[s] = 0;

        int qh = 0,qt = 1;

        q[0] = s;

        while(qh<qt){

            int v = q[qh++];

            for(int id:g[v]){

                edge &r = e[id];

                int to = r.b;

                if(r.c > r.flow && dis[to]>dis[v]+1){

                    dis[to] = dis[v]+1;

                    q[qt++] = to;

                }

            }

        }

        return dis[t]!=inf_int;

    }







    int dfs(int v,int flow){

        if(v==t)

            return flow;

        for(;ptr[v]<g[v].size();++ptr[v]){

            int id = g[v][ptr[v]];

            edge &r = e[id];

            if(r.c > r.flow && dis[r.b]==dis[v]+1){

                int pushed = dfs(r.b, min(flow, r.c - r.flow));

                if(pushed){

                    e[id].flow+=pushed;

                    e[id^1].flow-=pushed;

                    return pushed;

                }

            }

        }

        return 0;

    }



    void delete_all(){

        e.clear();

        for(int i = 0;i<n;++i){

            g[i].clear();

        }

    }



    void clear(){

        int m = e.size();

        for(int i = 0;i<m;++i){

            e[i].flow=0;

        }

    }





    int flow(){

        int res = 0;

        while(bfs()){

            fill(ptr,ptr+n,0);

            while(int pushed = dfs(s,inf_int)){

                res+=pushed;

            }

        }

        return res;

    }



} flow;



int n;

int p[N];

int q[N];

int A[N];

int B[N];



int main()

{

        //freopen("input.txt", "r", stdin);

        //freopen("output.txt", "w", stdout);



        ios_base::sync_with_stdio(0);



        cin >> n;

        for(int i = 0; i < n; i++){

                cin >> p[i];

        }

        for(int i = 0; i < n; i++){

                cin >> q[i];

        }

        int G = 0;

        for(int i = 0; i < n; i++){

                if(A[i] == 0){

                        G += 1;

                        A[i] = G;

                        int j = p[i];

                        while(j != i){

                                A[j] = G;

                                j = p[j];

                        }

                }

                if(B[i] == 0){

                        G += 1;

                        B[i] = G;

                        int j = q[i];

                        while(j != i){

                                B[j] = G;

                                j = q[j];

                        }

                }

        }

        G += 1;

        flow.init(0, G, G + 1);



        int res = n;

        for(int i = 0; i < n; i++){

                if(p[i] == i && q[i] == i){

                        res -= 1;

                } else if(p[i] == i){

                        flow.add_edge(B[i], G, 1);

                } else if(q[i] == i){

                        flow.add_edge(0, A[i], 1);

                } else{

                        flow.add_edge(B[i], A[i], 1);

                        if(p[i] == q[i]){

                                flow.add_edge(A[i], B[i], 1);

                        }

                }

        }

        res -= flow.flow();



        cout << res << '\n';

}


// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

//#pragma GCC optimize("Ofast")



#define fi first

#define se second



const int N = 100100;



using namespace std;



namespace Dinic {



	using F = int;

	const F INF = 1e9+1e8;



	const int N = 220000;

	const int M = N * 2;



	int fst[N], nxt[M], to[M];

	F cap[M];

	int dis[N], q[N], ptr[N];

	int E;



	void init() {

		memset(fst, -1, sizeof fst);

		E = 0;

	}

	inline void add_edge(int u, int v, F c) {

		to[E] = v, cap[E] = c, nxt[E] = fst[u], fst[u] = E++;

		to[E] = u, cap[E] = 0, nxt[E] = fst[v], fst[v] = E++;

	}

	inline bool bfs(int S, int T, int n) {

		memset(dis, -1, sizeof(int) * n);

		int h = 0, t = 0;

		dis[S] = 0, q[t++] = S;

		while (h < t) {

			int u = q[h++];

			for (int e = fst[u]; ~e; e = nxt[e]) if (cap[e] > 0 && dis[to[e]] == -1) {

				dis[to[e]] = dis[u] + 1, q[t++] = to[e];

				if (to[e] == T) return 1;

			}

		}

		return (dis[T] != -1);

	}

	F dfs(int u, int T, F f) {

		if (u == T) return f;

		for (int &e = ptr[u]; ~e; e = nxt[e]) if (cap[e] > 0 && dis[to[e]] > dis[u]) {

			F ret = dfs(to[e], T, min(f, cap[e]));

			if (ret > 0) {

				cap[e] -= ret, cap[e ^ 1] += ret;

				return ret;

			}

		}

		return 0;

	}

	F max_flow(int S, int T, int n) {

		F ret = 0;

		while (bfs(S, T, n)) {

			memcpy(ptr, fst, sizeof(int) * n);

			for (F cur; (cur = dfs(S, T, INF)) > 0; ret += cur);

		}

		return ret;

	}

};



int n;

int p[N];

int q[N];

int A[N];

int B[N];



int main()

{

        //freopen("input.txt", "r", stdin);

        //freopen("output.txt", "w", stdout);



        ios_base::sync_with_stdio(0);



        cin >> n;

        for(int i = 0; i < n; i++){

                cin >> p[i];

        }

        for(int i = 0; i < n; i++){

                cin >> q[i];

        }

        int G = 0;

        for(int i = 0; i < n; i++){

                if(A[i] == 0){

                        G += 1;

                        A[i] = G;

                        int j = p[i];

                        while(j != i){

                                A[j] = G;

                                j = p[j];

                        }

                }

                if(B[i] == 0){

                        G += 1;

                        B[i] = G;

                        int j = q[i];

                        while(j != i){

                                B[j] = G;

                                j = q[j];

                        }

                }

        }

        G += 1;

        Dinic::init();



        int res = n;

        for(int i = 0; i < n; i++){

                if(p[i] == i && q[i] == i){

                        res -= 1;

                } else if(p[i] == i){

                        Dinic::add_edge(B[i], G, 1);

                } else if(q[i] == i){

                        Dinic::add_edge(0, A[i], 1);

                } else{

                        Dinic::add_edge(B[i], A[i], 1);

                        if(p[i] == q[i]){

                                Dinic::add_edge(A[i], B[i], 1);

                        }

                }

        }

        res -= Dinic::max_flow(0, G, G + 1);



        cout << res << '\n';

}


// Fastest known solution for this problem: