Array and Operations

A. Array and Operations

Time Limit: 1000ms

Memory Limit: 262144KB

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

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

Output

Input

Output

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

  1 #include<stdio.h>

  2 #include<algorithm>

  3 #include<iostream>

  4 #include<stdlib.h>

  5 #include<queue>

  6 #include<string.h>

  7 #include<map>

  8 #include<vector>

  9 using namespace std;

 10 typedef long long LL;

 11 int  ans[105];

 12 typedef struct node

 13 {

 14         int x,y;

 15 } ss;

 16 typedef struct pp

 17 {

 18         int to;

 19         int cap;

 20         int rev;

 21 } aa;

 22 ss bns[105];

 23 bool prime[100005];

 24 int prime_table[100005];

 25 short int an[105][20000];

 26 map<int,int>my;

 27 vector<pp>vec[105];

 28 int level[105];

 29 int iter[105];

 30 void add(int from,int to,int cap);

 31 void bfs(int s);

 32 int dfs(int s,int t,int f);

 33 int max_flow(int s,int t);

 34 const int N = 1e9;

 35 int main(void)

 36 {

 37         int n,m;

 38         int i,j;

 39         for(i = 2; i <= 1000; i++)

 40         {

 41                 if(!prime[i])

 42                 {

 43                         for(j = i; (i*j) <= 100000; j++)

 44                         {

 45                                 prime[i*j] = true;

 46                         }

 47                 }

 48         }

 49         int cn = 0;

 50         for(i = 2; i <= 100000; i++)

 51         {

 52                 if(!prime[i])

 53                 {

 54                         my[i] = cn;

 55                         prime_table[cn++] = i;

 56                 }

 57         }

 58         scanf("%d %d",&n,&m);

 59         for(i = 1; i <= n; i++)

 60         {

 61                 scanf("%d",&ans[i]);

 62         }

 63         for(i = 0; i < m; i++)

 64         {

 65                 scanf("%d %d",&bns[i].x,&bns[i].y);

 66                 if(bns[i].x%2)

 67                         swap(bns[i].x,bns[i].y);

 68         }

 69         memset(an,0,sizeof(an));

 70         for(i = 1; i <= n; i++)

 71         {

 72                 int  x = ans[i];

 73                 int f = 0;

 74                 while(x>1&&f < cn)

 75                 {

 76                         while(x%prime_table[f]==0)

 77                         {

 78                                 x /= prime_table[f];

 79                                 an[i][f]++;

 80                         }

 81                         f++;

 82                         if((LL)prime_table[f]*(LL)prime_table[f] > x)

 83                                 break;

 84                 }

 85                 if(x>1)

 86                 {

 87                         if(!my.count(x))

 88                         {

 89                                 my[x] = cn;

 90                                 an[i][cn]++;

 91                                 prime_table[cn++] = x;

 92                         }

 93                         else

 94                         {

 95                                 an[i][my[x]]++;

 96                         }

 97                 }

 98         }

 99         int as = 0;

100         for(j = 0; j < cn; j++)

101         {

102                 for(i = 0; i <= 100; i++)

103                         vec[i].clear();

104                 for(i = 2; i <= n; i+=2)

105                 {

106                         if(an[i][j])

107                         {

108                                 add(0,i,an[i][j]);

109                         }

110                 }

111                 for(i= 1; i  <= n; i+=2)

112                 {

113                         if(an[i][j])

114                         {

115                                 add(i,n+1,an[i][j]);

116                         }

117                 }

118                 for(i = 0; i < m; i++)

119                 {

120                         add(bns[i].x,bns[i].y,1e9);

121                 }

122                 as += max_flow(0,n+1);

123         }

124         printf("%d\n",as);

125         return 0;

126 }

127 void add(int from,int to,int cap)

128 {

129         pp  nn;

130         nn.to = to;

131         nn.cap = cap;

132         nn.rev = vec[to].size();

133         vec[from].push_back(nn);

134         nn.to = from;

135         nn.cap=0;

136         nn.rev = vec[from].size()-1;

137         vec[to].push_back(nn);

138 }

139 void bfs(int s)

140 {

141         queue<int>que;

142         memset(level,-1,sizeof(level));

143         level[s]=0;

144         que.push(s);

145         while(!que.empty())

146         {

147                 int v=que.front();

148                 que.pop();

149                 int i;

150                 for(i=0; i<vec[v].size(); i++)

151                 {

152                         pp e=vec[v][i];

153                         if(level[e.to]==-1&&e.cap>0)

154                         {

155                                 level[e.to]=level[v]+1;

156                                 que.push(e.to);

157                         }

158                 }

159         }

160 }

161 int dfs(int s,int t,int f)

162 {

163         if(s==t)

164                 return f;

165         for(int &i=iter[s]; i<vec[s].size(); i++)

166         {

167                 pp &e=vec[s][i];

168                 if(level[e.to]>level[s]&&e.cap>0)

169                 {

170                         int r=dfs(e.to,t,min(e.cap,f));

171                         if(r>0)

172                         {

173                                 e.cap-=r;

174                                 vec[e.to][e.rev].cap+=r;

175                                 return r;

176                         }

177                 }

178         }

179         return 0;

180 }

181 int max_flow(int s,int t)

182 {

183         int flow=0;

184         for(;;)

185         {

186                 bfs(s);

187                 if(level[t]<0)return flow;

188                 memset(iter,0,sizeof(iter));

189                 int f;

190                 while((f=dfs(s,t,N)) >0)

191                 {

192                         flow += f;

193                 }

194         }

195 }