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 (i1, j1), (i2, j2), ..., (im, jm). Each good pair (ik, jk) meets the following conditions: ik + jk is an odd number and 1 ≤ ik < jk ≤ n.
In one operation you can perform a sequence of actions:
- take one of the good pairs (ik, jk) and some integer v (v > 1), which divides both numbers a[ik] and a[jk];
- 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] ≤ 109) — the description of the array.
The following m lines contain the description of good pairs. The k-th line contains two space-separated integers ik, jk (1 ≤ ik < jk ≤ n, ik + jk 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 28 3 81 22 3
Output
0
Input
3 28 12 81 22 3
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 }