B - Prime Independence （二分图最大匹配+因子分解）

B - Prime Independence

 

1356 - Prime Independence

PDF (English)

Statistics

Forum

Time Limit: 3 second(s)

Memory Limit: 32 MB

A set of integers is called prime independent if none of its member is a prime multiple of another member. An integer a is said to be a prime multiple of b if,

a = b x k (where k is a prime [1])

So, 6 is a prime multiple of 2, but 8 is not. And for example, {2, 8, 17} is prime independent but {2, 8, 16} or {3, 6} are not.

Now, given a set of distinct positive integers, calculate the largest prime independent subset.

Input

Input starts with an integer T (≤ 20), denoting the number of test cases.

Each case starts with an integer N (1 ≤ N ≤ 40000) denoting the size of the set. Next line contains N integers separated by a single space. Each of these N integers are distinct and between 1 and 500000 inclusive.

Output

For each case, print the case number and the size of the largest prime independent subset.

Sample Input	Output for Sample Input
3 5 2 4 8 16 32 5 2 3 4 6 9 3 1 2 3	Case 1: 3 Case 2: 3 Case 3: 2

Note

1.      An integer is said to be a prime if it's divisible by exactly two distinct integers. First few prime numbers are 2, 3, 5, 7, 11, 13, ...

2.      Dataset is huge, use faster I/O methods.

    题意：求最大的 prime multiple组合数；

       二分图最大匹配，直接用n减就可以了。。。。。

      

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn = 50000;

int t, n, n1, n2;

vector<int> g[maxn + 10];
int mx[maxn +10], my[maxn + 10];
queue<int> que;
int dx[maxn + 10], dy[maxn + 10], num[maxn + 10], id[10*maxn + 10], pos[10*maxn + 10];
bool vis[maxn + 10];



bool Find(int u) {
    for(int i = 0; i < g[u].size(); i++){
        if(!vis[g[u][i]] && dy[g[u][i]] == dx[u] + 1){
            vis[g[u][i]] = true;
            if(!my[g[u][i]] || Find(my[g[u][i]])) {
                mx[u] = g[u][i];
                my[g[u][i]] = u;
                return true;
            }
        }
    }
    return false;
}

int Hmatch()
{
    memset(mx, 0, sizeof(mx));
    memset(my, 0, sizeof(my));
    int ans = 0;
    while(true) {
        bool flag = false;
        while(!que.empty()) que.pop();
        memset(dx, 0, sizeof(dx));
        memset(dy, 0, sizeof(dy));
        for(int i = 1; i <= n1; i++)
            if(!mx[i]) que.push(i);
        while(!que.empty()) {
            int u = que.front();
            que.pop();
            for(int i = 0; i < g[u].size(); i++)
                if(!dy[g[u][i]]) {
                    dy[g[u][i]] = dx[u] + 1;
                    if(my[g[u][i]]) {
                        dx[my[g[u][i]]] = dy[g[u][i]] + 1;
                        que.push(my[g[u][i]]);
                    } else flag = true;
                }
        }
        if(!flag) break;
        memset(vis, 0, sizeof(vis));
        for(int i = 1; i <= n1; i++)
         if(!mx[i]&&Find(i)) ans++;
    }
    return ans;
}

void init()
{
    n1 = 0, n2 = 0;
    cin>>n;
    memset(num, 0, sizeof(num));
    memset(id, 0, sizeof(id));
    memset(pos, 0, sizeof(pos));
    for(int i  = 1; i <= n; i++) scanf("%d", &num[i]);
    sort(num+1, num+n+1);
    for(int i  = 1; i <= n; i++) pos[num[i]] = i;
}


int main()
{
    int cas = 0;
    scanf("%d",&t);
    while(t--)
    {
        init();
        for(int i = 1; i <= n; i++) {
            int factor[10000];
            int cnt=0,sum=0, k = num[i];
            for(int j = 2; k>1 && j <= sqrt(k); j++)
            if(k%j==0) {
                        factor[cnt++] = j;
                        while(k%j==0) {
                             k/=j;
                             sum++;
                         }
            }
            if(k>1) {    //k有可能是质数
                     factor[cnt++]=k;
                     sum++;
           }
           if(sum % 2 == 0) id[num[i]] = (++n1);
           else id[num[i]] = (++n2);
           for(int j = 0; j < cnt; j++)
           {
                int c = num[i]/factor[j];
                if(id[c]) {
                    if(sum&1) g[id[c]].push_back(id[num[i]]);
                    else g[id[num[i]]].push_back(id[c]);
                }
           }
        }
        printf("Case %d: %d\n", ++cas, n - Hmatch());
        for(int i = 1; i <= n1; i++)
            g[i].clear();
    }
    return 0;
}