CF1630F-最小割、Dilworth定理

link：https://codeforces.com/contest/1630/problem/F

给你一个由 $n$ 个顶点组成的无向图，编号从 $1$ 到 $n$ ，其中顶点 $i$ 的值为 $a_i$ ，所有值 $a_i$ 都是不同的。如果 $a_u$ 整除 $a_v$ ，则两个顶点 $u$ 和 $v$ 之间存在一条边。当删除一个顶点时，也就删除了与之相连的所有边。
问最少删几个点使得得到的是二分图。
$1\le n\le 5\times {10}^4$.

---

首先整除是个偏序关系，它比DAG的性质来得强：如果 $a|b,b|c$ 则必有 $a|c$，翻译过来就是如果有边 $u\to v,v\to w$ 则必有 $u\to w$，这样就出现了一个三元环。
换言之如果把无向边改成有向边（例如大的连小的），如果要得到二分图，那么不能有长度 $\ge 2$ 的链，即每条链最长是 $1$，也就是说每个点要么只有入度，要么只有出度，此时也一定是二分图。

那么就能把点分成两类，拆点：$u$ 表示 $u$ 只有出度，$u^{\prime }$ 表示只有入度，$(u,u^{\prime })$ 连一条无向边表示两个事件不能同时发生。如果原图有 $u\to v$ 的边，则 $u,v$ 明显也不能同时有出度（这意味着 $v$ 有入度），因此有 $(u,v)$ 的边，类似地会有 $(u^{\prime },v^{\prime }),(u^{\prime },v)$ 这些边

这样得到了一张新的二分图，图上任意一条边表示两端的事件不能同时发生，如果要保留最多的点，相当于求最大独立集，即求最大的点集 $V^{\prime }\subset V$， 使得 $V^{\prime }$ 内任意两个点之间无边。

而注意到 这张二分图是可以变成偏序集的：

$ans=n-$ 留下的最多点

留下的最多点=这张图的最大独立集=补图的最长链，补图的边数太多了，而根据Dilworth定理，偏序集上的最长链=补图的最小边覆盖，因此图的最大独立集=最小边覆盖，对这张DAG求个最小路径覆盖=拆点后点数-最小割。

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define endl '\n'
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
using namespace std;
typedef pair<int,int> pii;
 
template<class T>
struct Dinic{//ind from 0 to n-1
    struct Edge{
        int to;T cap;
        Edge(int to,T cap):to(to),cap(cap){}
    };
    int n;
    vector<Edge> E;
    vector<vector<int>> G;
    vector<int> cur,h;
 
    Dinic(int n=0){init(n);}
    void init(int n){
        this->n=n;
        E.clear();
        cur.resize(n);
        h.resize(n);
        G.assign(n,{});
    }
    void addEdge(int u,int v,T c){
        G[u].push_back(E.size());E.emplace_back(v,c);
        G[v].push_back(E.size());E.emplace_back(u,0);
    }
    bool bfs(int s,int t){
        h.assign(n,-1);
        queue<int> que;
        h[s]=0;
        que.push(s);
        while(!que.empty()){
            const int u=que.front();
            que.pop();
            for(auto i:G[u]){
                auto [v,c]=E[i];
                if(c>0&&h[v]==-1){
                    h[v]=h[u]+1;
                    if(v==t)return true;
                    que.push(v);
                }
            }
        }
        return false;
    }
    T dfs(int u,int t,T f){
        if(u==t)return f;
        auto r=f;
        for(int &i=cur[u];i<(int)G[u].size();i++){
            const int j=G[u][i];
            auto [v,c]=E[j];
            if(c>0&&h[v]==h[u]+1){
                auto a=dfs(v,t,std::min(r,c));
                E[j].cap-=a;
                E[j^1].cap+=a;
                r-=a;
                if(r==0)return f;
            }
        }
        return f-r;
    }
    T work(int s,int t){
        T ans=0;
        while(bfs(s,t)){
            cur.assign(n,0);
            ans+=dfs(s,t,std::numeric_limits<T>::max());
        }
        return ans;
    }
};
int main(){
    fastio;
    constexpr int N=5e4;
    constexpr int INF=std::numeric_limits<int>::max();
    int tc;cin>>tc;
    vector<vector<int>> divisor(N+5);
    rep(i,1,N)for(int j=i+i;j<=N;j+=i)divisor[j].push_back(i);
 
    while(tc--){
        int n;cin>>n;
        vector<pii> E;
        auto work=[&](int n)->int{
            int st=2*n,ed=2*n+1;
            Dinic<int> flow(ed+1);
            for(auto [u,v]:E)flow.addEdge(u,v+n,1);
            rep(i,0,n-1){
                flow.addEdge(st,i,1);
                flow.addEdge(i+n,ed,1);
            }
            return n-flow.work(st,ed);
        };
        set<int> S;
        map<int,int> idx;
        rep(i,0,n-1){
            int x;cin>>x;
            S.insert(x);
            idx[x]=i;
            E.push_back({idx[x]+n,idx[x]});
        }
        for(auto u:S){
            for(auto v:divisor[u])if(S.contains(v)){
                E.push_back({idx[u],idx[v]});
                E.push_back({idx[u]+n,idx[v]+n});
                E.push_back({idx[u]+n,idx[v]});
            }
        }
        cout<<n-work(n<<1)<<endl;
    }
    return 0;
}