Lightoj1356

题目链接：https://vjudge.net/problem/LightOJ-1356

题目大意：

　　T个 test case，每个 test case 给出一个 N 个数的集合。请找出一个最大的子集，使得子集中的任何一个数除以子集中的任意的另一个数所得到的数不是质数。

解题思路：

　　先用素数筛找出 1 到 500000 的所有质数。

　　在输入一个集合的时候，我们顺便记录下输入的这个数在输入数组中的位置，找出它的所有质因数，记录下质因数的总个数，用一个vector记录下所有 “不同的” 质因数。

　　遍历输入数组中的每一个数，对于每个数，遍历其所有 “不同的” 质因数，如果找到这样的一个质因数：该数除以这个质因数能得到输入数组中的另一个数，那么将这两个数连边。

　　将由上述的连边操作得到的图中的点分成两类：质因数总个数为奇数的点和质因数总个数为偶数的点（这个划分有点隐晦，我多说两句：其实，对于连边的两个数，二者各自的所有质因数其实就只有一个质数的差别，其中一个数的所有质因数中有这个质数，但另一个数没有，其他的质因数都相同；所以，他们质因数的总个数相差 1，故其中一个为奇数，一个为偶数），这样一来，这个图就变成一个二分图了。而答案其实就是求这个二分图的最大独立集。

　　另：用匈牙利算法者，T！用 Hopcroft-Carp者方有可能AC。

AC代码：

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
#include <queue>

using namespace std;
const int inf=0x3f3f3f3f;

bool prime[500003];
int have[500003],num[40003];
int prims[300003];

vector<int> G[40003];
int uN;
int l[40003];
int Mx[40003],My[40003];
int dx[40003],dy[40003];
int dis;
bool used[40003];
bool SearchP(){
    queue<int>Q;
    dis=inf;
    memset(dx,-1,sizeof(dx));
    memset(dy,-1,sizeof(dy));
    for(int i=0;i<uN;i++){
        if(Mx[l[i]]==-1){
            Q.push(l[i]);
            dx[l[i]]=0;
        }
    }
    while(!Q.empty()){
        int u=Q.front();
        Q.pop();
        if(dx[u]>dis)   break;
        int sz=G[u].size();
        for(int i=0;i<sz;i++){
            int v=G[u][i];
            if(dy[v]==-1){
                dy[v]=dx[u]+1;
                if(My[v]==-1) dis=dy[v];
                else{
                    dx[My[v]]=dy[v]+1;
                    Q.push(My[v]);
                }
            }
        }
    }
    return dis!=inf;
}
bool DFS(int u){
    int sz=G[u].size();
    for(int i=0;i<sz;i++){
        int v=G[u][i];
        if(!used[v]&&dy[v]==dx[u]+1){
            used[v]=true;
            if(My[v]!=-1&&dy[v]==dis)   continue;
            if(My[v]==-1||DFS(My[v])){
                My[v]=u;
                Mx[u]=v;
                return true;
            }
        }
    }
    return false;
}
int MaxMatch(){
    int res=0;
    memset(Mx,-1,sizeof(Mx));
    memset(My,-1,sizeof(My));
    while(SearchP()){
        memset(used,false,sizeof(used));
        for(int i=0;i<uN;i++){
            if(Mx[l[i]]==-1&&DFS(l[i]))   res++;
        }
    }
    return res;
}
void init(){
    memset(prime,true,sizeof(prime));
    prime[0]=prime[1]=false;
    int cnt=0;
    for(int i=2;i<=500000;i++){
        if(prime[i]){
            prims[cnt++]=i;
            for(int j=2*i;j<=500000;j+=i)
                prime[j]=false;
        }
    }
}
int zhis[40003];
vector<int> zhiyinshu[40003];
int main(){
    init();
    int T,N;
    scanf("%d",&T);
    for(int t=1;t<=T;t++){
        scanf("%d",&N);
        memset(have,0,sizeof(have));
        memset(zhis,0,sizeof(zhis));
        for(int i=1;i<=N;i++){
            G[i].clear();
            zhiyinshu[i].clear();
            scanf("%d",&num[i]);
            have[num[i]]=i;
            int tmp=num[i];
            for(int j=0;;j++){
                if(prime[tmp]){
                    zhiyinshu[i].push_back(tmp);
                    zhis[i]++;
                    break;
                }
                if(tmp%prims[j]==0){
                    tmp/=prims[j];
                    zhiyinshu[i].push_back(prims[j]);
                    zhis[i]++;
                    while(tmp%prims[j]==0){
                        tmp/=prims[j];
                        zhis[i]++;
                    }
                }
                if(tmp<prims[j])    break;
            }
        }
        for(int i=1;i<=N;i++){
            for(int j=0;j<zhiyinshu[i].size();j++){
                if(have[num[i]/zhiyinshu[i][j]]){
                    int u=have[num[i]/zhiyinshu[i][j]];
                    G[i].push_back(u);
                    G[u].push_back(i);
                }
            }
        }

        uN=0;
        for(int i=1;i<=N;i++){
            if(zhis[i]%2==1){
                l[uN++]=i;
            }
        }
        printf("Case %d: %d
",t,N-MaxMatch());
    }
    return 0;
}