Array and Operations

A. Array and Operations

Time Limit: 1000ms

Memory Limit: 262144KB

64-bit integer IO format: %I64d      Java class name: (Any)

Submit Status

You have written on a piece of paper an array of n positive integers a[1], a[2], ..., a[n] and m good pairs of integers (i₁, j₁), (i₂, j₂), ..., (i_m, j_m). Each good pair (i_k, j_k) meets the following conditions: i_k + j_k is an odd number and 1 ≤ i_k < j_k ≤ n.

In one operation you can perform a sequence of actions:

• take one of the good pairs (i_k, j_k) and some integer v (v > 1), which divides both numbers a[i_k] and a[j_k];
• divide both numbers by v, i. e. perform the assignments: and .

Determine the maximum number of operations you can sequentially perform on the given array. Note that one pair may be used several times in the described operations.

Input

The first line contains two space-separated integers n, m (2 ≤ n ≤ 100, 1 ≤ m ≤ 100).

The second line contains n space-separated integers a[1], a[2], ..., a[n] (1 ≤ a[i] ≤ 10⁹) — the description of the array.

The following m lines contain the description of good pairs. The k-th line contains two space-separated integers i_k, j_k (1 ≤ i_k < j_k ≤ n, i_k + j_k is an odd number).

It is guaranteed that all the good pairs are distinct.

Output

Output the answer for the problem.

Sample Input

Input

3 2
8 3 8
1 2
2 3

Output

0

Input

3 2
8 12 8
1 2
2 3

Output

2
思路：最大流；
首先这个可以看成二分图，因为和是奇数，所以两个点的下标一定是一个奇数一个偶数，那么自然想到最大匹配。
要保证次数最多，所以每次除的必定是质因子。所以我们把所有数的质因子打出来，然后每次我们只处理一个质因子。分别建立一个源点，一个汇点，
源点和偶数点连，边权就是这个数有这个数有这个质数的个数。然后汇点就奇数点连，然后再将给你的边连下，跑最大流就行了。

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<stdlib.h>
#include<queue>
#include<string.h>
#include<map>
#include<vector>
using namespace std;
typedef long long LL;
int  ans[105];
typedef struct node
{
        int x,y;
} ss;
typedef struct pp
{
        int to;
        int cap;
        int rev;
} aa;
ss bns[105];
bool prime[100005];
int prime_table[100005];
short int an[105][20000];
map<int,int>my;
vector<pp>vec[105];
int level[105];
int iter[105];
void add(int from,int to,int cap);
void bfs(int s);
int dfs(int s,int t,int f);
int max_flow(int s,int t);
const int N = 1e9;
int main(void)
{
        int n,m;
        int i,j;
        for(i = 2; i <= 1000; i++)
        {
                if(!prime[i])
                {
                        for(j = i; (i*j) <= 100000; j++)
                        {
                                prime[i*j] = true;
                        }
                }
        }
        int cn = 0;
        for(i = 2; i <= 100000; i++)
        {
                if(!prime[i])
                {
                        my[i] = cn;
                        prime_table[cn++] = i;
                }
        }
        scanf("%d %d",&n,&m);
        for(i = 1; i <= n; i++)
        {
                scanf("%d",&ans[i]);
        }
        for(i = 0; i < m; i++)
        {
                scanf("%d %d",&bns[i].x,&bns[i].y);
                if(bns[i].x%2)
                        swap(bns[i].x,bns[i].y);
        }
        memset(an,0,sizeof(an));
        for(i = 1; i <= n; i++)
        {
                int  x = ans[i];
                int f = 0;
                while(x>1&&f < cn)
                {
                        while(x%prime_table[f]==0)
                        {
                                x /= prime_table[f];
                                an[i][f]++;
                        }
                        f++;
                        if((LL)prime_table[f]*(LL)prime_table[f] > x)
                                break;
                }
                if(x>1)
                {
                        if(!my.count(x))
                        {
                                my[x] = cn;
                                an[i][cn]++;
                                prime_table[cn++] = x;
                        }
                        else
                        {
                                an[i][my[x]]++;
                        }
                }
        }
        int as = 0;
        for(j = 0; j < cn; j++)
        {
                for(i = 0; i <= 100; i++)
                        vec[i].clear();
                for(i = 2; i <= n; i+=2)
                {
                        if(an[i][j])
                        {
                                add(0,i,an[i][j]);
                        }
                }
                for(i= 1; i  <= n; i+=2)
                {
                        if(an[i][j])
                        {
                                add(i,n+1,an[i][j]);
                        }
                }
                for(i = 0; i < m; i++)
                {
                        add(bns[i].x,bns[i].y,1e9);
                }
                as += max_flow(0,n+1);
        }
        printf("%d
",as);
        return 0;
}
void add(int from,int to,int cap)
{
        pp  nn;
        nn.to = to;
        nn.cap = cap;
        nn.rev = vec[to].size();
        vec[from].push_back(nn);
        nn.to = from;
        nn.cap=0;
        nn.rev = vec[from].size()-1;
        vec[to].push_back(nn);
}
void bfs(int s)
{
        queue<int>que;
        memset(level,-1,sizeof(level));
        level[s]=0;
        que.push(s);
        while(!que.empty())
        {
                int v=que.front();
                que.pop();
                int i;
                for(i=0; i<vec[v].size(); i++)
                {
                        pp e=vec[v][i];
                        if(level[e.to]==-1&&e.cap>0)
                        {
                                level[e.to]=level[v]+1;
                                que.push(e.to);
                        }
                }
        }
}
int dfs(int s,int t,int f)
{
        if(s==t)
                return f;
        for(int &i=iter[s]; i<vec[s].size(); i++)
        {
                pp &e=vec[s][i];
                if(level[e.to]>level[s]&&e.cap>0)
                {
                        int r=dfs(e.to,t,min(e.cap,f));
                        if(r>0)
                        {
                                e.cap-=r;
                                vec[e.to][e.rev].cap+=r;
                                return r;
                        }
                }
        }
        return 0;
}
int max_flow(int s,int t)
{
        int flow=0;
        for(;;)
        {
                bfs(s);
                if(level[t]<0)return flow;
                memset(iter,0,sizeof(iter));
                int f;
                while((f=dfs(s,t,N)) >0)
                {
                        flow += f;
                }
        }
}