分析性质+排列置换环+最小割：1024T4

http://cplusoj.com/d/senior/p/SS231024D

相当于各选一些置换环进行一次位移

我们考虑只对A进行置换。对于一个大小>1的环，如果对其进行位移，一定可以使这些位完全不同。

因此，如果我们置换B，置换的意义是什么？是把A中自环的位置统计掉，使这些位置不同。

但如果我们再置换B，可能会和之前已经置换的A在某些地方相同，这部分需要减去。这就提示我们要用网络流。

在此之前我们可以先证明一个结论，对于每个位置，我们总可以使其置换环A或置换环B至少有一个被换过。

所以要么A选，要么B选，要么AB同选。对于选东西的问题，直接用网络流很难维护，所以考虑最小割。

我们要用最小割。我们发现如果直接使相同位置最小有点难做，考虑反过来。我们先钦定所有位置不同，再使其变回相同。（也就是也开始全选）

我们发现这长得很像一个二分图形式。我们就考虑S->A，表示A不选。A->B，表示两个都选。B->T同理。

初始所有位置不同，我们直接令答案为 $\sum sze$，也就是A和B中所有置换环的大小（非自环）

但这显然有重，这样我们最小割才有意义。假如我们割A，代表只选B。割B，代表只选A，似乎对应上了？

割中间的代价，相当于两个都选，那么应该是重复部分大小+相同部分大小。

因为两个位移后相同也不应该计算。

#include<bits/stdc++.h>
using namespace std;


namespace atcoder {

	namespace internal {
	
	template <class T> struct simple_queue {
	    std::vector<T> payload;
	    int pos = 0;
	    void reserve(int n) { payload.reserve(n); }
	    int size() const { return int(payload.size()) - pos; }
	    bool empty() const { return pos == int(payload.size()); }
	    void push(const T& t) { payload.push_back(t); }
	    T& front() { return payload[pos]; }
	    void clear() {
	        payload.clear();
	        pos = 0;
	    }
	    void pop() { pos++; }
	};
	
	}  // namespace internal

	template <class Cap> struct mf_graph {
	  public:
	    mf_graph() : _n(0) {}
	    explicit mf_graph(int n) : _n(n), g(n) {}
	
	    int add_edge(int from, int to, Cap cap) {
	        assert(0 <= from && from < _n);
	        assert(0 <= to && to < _n);
	        assert(0 <= cap);
	        int m = int(pos.size());
	        pos.push_back({from, int(g[from].size())});
//	        printf("%lld -> %lld | %lld\n", from, to, cap); 
	        int from_id = int(g[from].size());
	        int to_id = int(g[to].size());
	        if (from == to) to_id++;
	        g[from].push_back(_edge{to, to_id, cap});
	        g[to].push_back(_edge{from, from_id, 0});
	        return m;
	    }
	
	    struct edge {
	        int from, to;
	        Cap cap, flow;
	    };
	
	    edge get_edge(int i) {
	        int m = int(pos.size());
	        assert(0 <= i && i < m);
	        auto _e = g[pos[i].first][pos[i].second];
	        auto _re = g[_e.to][_e.rev];
	        return edge{pos[i].first, _e.to, _e.cap + _re.cap, _re.cap};
	    }
	    std::vector<edge> edges() {
	        int m = int(pos.size());
	        std::vector<edge> result;
	        for (int i = 0; i < m; i++) {
	            result.push_back(get_edge(i));
	        }
	        return result;
	    }
	    void change_edge(int i, Cap new_cap, Cap new_flow) {
	        int m = int(pos.size());
	        assert(0 <= i && i < m);
	        assert(0 <= new_flow && new_flow <= new_cap);
	        auto& _e = g[pos[i].first][pos[i].second];
	        auto& _re = g[_e.to][_e.rev];
	        _e.cap = new_cap - new_flow;
	        _re.cap = new_flow;
	    }
	
	    Cap flow(int s, int t) {
	        return flow(s, t, std::numeric_limits<Cap>::max());
	    }
	    Cap flow(int s, int t, Cap flow_limit) {
	        assert(0 <= s && s < _n);
	        assert(0 <= t && t < _n);
	        assert(s != t);
	
	        std::vector<int> level(_n), iter(_n);
	        internal::simple_queue<int> que;
	
	        auto bfs = [&]() {
	            std::fill(level.begin(), level.end(), -1);
	            level[s] = 0;
	            que.clear();
	            que.push(s);
	            while (!que.empty()) {
	                int v = que.front();
	                que.pop();
	                for (auto e : g[v]) {
	                    if (e.cap == 0 || level[e.to] >= 0) continue;
	                    level[e.to] = level[v] + 1;
	                    if (e.to == t) return;
	                    que.push(e.to);
	                }
	            }
	        };
	        auto dfs = [&](auto self, int v, Cap up) {
	            if (v == s) return up;
	            Cap res = 0;
	            int level_v = level[v];
	            for (int& i = iter[v]; i < int(g[v].size()); i++) {
	                _edge& e = g[v][i];
	                if (level_v <= level[e.to] || g[e.to][e.rev].cap == 0) continue;
	                Cap d =
	                    self(self, e.to, std::min(up - res, g[e.to][e.rev].cap));
	                if (d <= 0) continue;
	                g[v][i].cap += d;
	                g[e.to][e.rev].cap -= d;
	                res += d;
	                if (res == up) return res;
	            }
	            level[v] = _n;
	            return res;
	        };
	
	        Cap flow = 0;
	        while (flow < flow_limit) {
	            bfs();
	            if (level[t] == -1) break;
	            std::fill(iter.begin(), iter.end(), 0);
	            Cap f = dfs(dfs, t, flow_limit - flow);
	            if (!f) break;
	            flow += f;
	        }
	        return flow;
	    }
	
	    std::vector<bool> min_cut(int s) {
	        std::vector<bool> visited(_n);
	        internal::simple_queue<int> que;
	        que.push(s);
	        while (!que.empty()) {
	            int p = que.front();
	            que.pop();
	            visited[p] = true;
	            for (auto e : g[p]) {
	                if (e.cap && !visited[e.to]) {
	                    visited[e.to] = true;
	                    que.push(e.to);
	                }
	            }
	        }
	        return visited;
	    }
	
	  private:
	    int _n;
	    struct _edge {
	        int to, rev;
	        Cap cap;
	    };
	    std::vector<std::pair<int, int>> pos;
	    std::vector<std::vector<_edge>> g;
	};

}  // namespace atcoder

using namespace atcoder;


//#define int long long
inline int read(){int x=0,f=1;char ch=getchar(); while(ch<'0'||
ch>'9'){if(ch=='-')f=-1;ch=getchar();}while(ch>='0'&&ch<='9'){
x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}return x*f;}
#define Z(x) (x)*(x)
#define pb push_back
//mt19937 rand(time(0));
//mt19937_64 rand(time(0));
//srand(time(0));
#define N 100010
//#define M
//#define mo
int n, m, i, j, k, T;
int S, a[N], b[N], ans; 
int A[N], B[N], wa[N], wb[N]; 
map<pair<int, int>, int>mp; 

int fa(int x) {
	if(A[x]==x) return x; 
	return A[x]=fa(A[x]); 
}

int fb(int x) {
	if(B[x]==x) return x; 
	return B[x]=fb(B[x]); 
}

signed main()
{
//	freopen("in.txt", "r", stdin);
//	freopen("out.txt", "w", stdout);
		freopen("permutation.in", "r", stdin);
	freopen("permutation.out", "w", stdout);
//	T=read();
//	while(T--) {
//
//	}
	n=read(); ans=0; 
	mf_graph<int>G(2*n+10); S=2*n+1; T=2*n+2; 
	for(i=1; i<=n; ++i) A[i]=B[i]=i; 
	for(i=1; i<=n; ++i) a[i]=read(), A[fa(i)]=fa(a[i]); 
	for(i=1; i<=n; ++i) b[i]=read(), B[fb(i)]=fb(b[i]); 
	for(i=1; i<=n; ++i) wa[fa(i)]++, wb[fb(i)]++; 
//	for(i=1; i<=n; ++i) printf("%d ", wa[i]); printf("\n"); 
//	for(i=1; i<=n; ++i) printf("%d ", wb[i]); printf("\n"); 
	for(i=1; i<=n; ++i) {
		if(fa(i)==i && wa[i]>1) G.add_edge(S, i, wa[i]), ans+=wa[i]; 
		if(fb(i)==i && wb[i]>1) G.add_edge(i+n, T, wb[i]), ans+=wb[i]; 
	}
	for(i=1; i<=n; ++i) {
		++mp[{fa(a[i]), fb(b[i])}]; 
		if(a[i]==b[i]) ++mp[{fa(a[i]), fb(b[i])}]; 
	}
	for(i=1; i<=n; ++i) {
		auto &k = mp[{fa(a[i]), fb(b[i])}]; 
		if(k) 
			G.add_edge(fa(a[i]), fb(b[i])+n, k), k=0; 
	}
	k=G.flow(S, T); ans-=k; 
	printf("%d", n-ans); 
	return 0;
}