POJ2429 GCD & LCM Inverse pollard_rho大整数分解

Given two positive integers a and b, we can easily calculate the greatest common divisor (GCD) and the least common multiple (LCM) of a and b. But what about the inverse? That is: given GCD and LCM, finding a and b.

Input

The input contains multiple test cases, each of which contains two positive integers, the GCD and the LCM. You can assume that these two numbers are both less than 2^63.

Output

For each test case, output a and b in ascending order. If there are multiple solutions, output the pair with smallest a + b.

Sample Input

3 60

Sample Output

12 15

题意：给出两个数的最大公约数和最小公倍数，让你找出满足条件的两个数，使他们的和最小。

题解：

对于两个数a,b和他们的最大公约数gcd以及最小公倍数lcm，有lcm=a*b/gcd，进一步变形可以得到：（a/gcd * b/gcd）*gcd=lcm，即(a/gcd * b/gcd)=lcm/gcd，我们令m=a/gcd,n=b/gcd，那么问题就变为了：找出两个互素的整数，使他们的乘积为key=lcm/gcd。我们可以用pollard_rho大整数分解的方法找出lcm/gcd的所有素因子，然后dfs找出任意几个素数因子之积(设为x)，设y=key/x，找出最小的x+y就行了

代码：

  1 #include <cstdio>
  2 
  3 #include <iostream>
  4 
  5 #include <cstdlib>
  6 
  7 #include <cmath>
  8 
  9 #include <algorithm>
 10 
 11  
 12 
 13 #define times 10
 14 
 15 #define N 501
 16 
 17 using namespace std;
 18 
 19 typedef unsigned long long LL;
 20 
 21 const LL INF=(LL)1<<61;
 22 
 23 LL key,ct,cnt,gd,lm,resa,resb,mini;
 24 
 25 LL fac[N],num[N];
 26 
 27  
 28 
 29 LL gcd(LL a,LL b)
 30 
 31 {
 32 
 33     return b?gcd(b,a%b):a;
 34 
 35 }
 36 
 37  
 38 
 39 LL multi(LL a,LL b,LL m)
 40 
 41 {
 42 
 43     LL ans=0;
 44 
 45     a%=m;
 46 
 47     while(b)
 48 
 49     {
 50 
 51         if(b&1)
 52 
 53         {
 54 
 55             ans=(ans+a)%m;
 56 
 57             b--;
 58 
 59         }
 60 
 61         b>>=1;
 62 
 63         a=(a+a)%m;
 64 
 65     }
 66 
 67     return ans;
 68 
 69 }
 70 
 71  
 72 
 73 LL quick_mod(LL a,LL b,LL m)
 74 
 75 {
 76 
 77     LL ans=1;
 78 
 79     a%=m;
 80 
 81     while(b)
 82 
 83     {
 84 
 85         if(b&1)
 86 
 87         {
 88 
 89             ans=multi(ans,a,m);
 90 
 91             b--;
 92 
 93         }
 94 
 95         b>>=1;
 96 
 97         a=multi(a,a,m);
 98 
 99     }
100 
101     return ans;
102 
103 }
104 
105  
106 
107 bool Miller_Rabin(LL n)
108 
109 {
110 
111     if(n==2) return true;
112 
113     if(n<2||!(n&1)) return false;
114 
115     LL m=n-1;
116 
117     int k=0;
118 
119     while(!(m&1))
120 
121     {
122 
123         k++;
124 
125         m>>=1;
126 
127     }
128 
129     for(int i=0;i<times;i++)
130 
131     {
132 
133         LL a=rand()%(n-1)+1;
134 
135         LL x=quick_mod(a,m,n);
136 
137         LL y=0;
138 
139         for(int j=0;j<k;j++)
140 
141         {
142 
143             y=multi(x,x,n);
144 
145             if(y==1&&x!=1&&x!=n-1) return false;
146 
147             x=y;
148 
149         }
150 
151         if(y!=1) return false;
152 
153     }
154 
155     return true;
156 
157 }
158 
159  
160 
161 LL Pollard_rho(LL n,LL c)
162 
163 {
164 
165     LL i=1,k=2;
166 
167     LL x=rand()%(n-1)+1;
168 
169     LL y=x;
170 
171     while(true)
172 
173     {
174 
175         i++;
176 
177         x=(multi(x,x,n)+c)%n;
178 
179         LL d=gcd((y-x+n)%n,n);
180 
181         if(1<d&&d<n) return d;
182 
183         if(y==x) return n;
184 
185         if(i==k)
186 
187         {
188 
189             y=x;
190 
191             k<<=1;
192 
193         }
194 
195     }
196 
197 }
198 
199  
200 
201 void Find(LL n,LL c)
202 
203 {
204 
205     if(n==1) return ;
206 
207     if(Miller_Rabin(n))
208 
209     {
210 
211         fac[ct++]=n;
212 
213         return ;
214 
215     }
216 
217     LL p=n;
218 
219     LL k=c;
220 
221     while(p>=n) p=Pollard_rho(p,c--);
222 
223     Find(p,k);
224 
225     Find(n/p,k);
226 
227 }
228 
229  
230 
231 void dfs(LL dept,LL product)
232 
233 {//dept为递归深度，product为其中一个因子
234 
235     if(dept==cnt)
236 
237     {
238 
239         LL a=product;
240 
241         LL b=key/a;
242 
243         if(gcd(a,b)==1)
244 
245         {
246 
247             a*=gd;
248 
249             b*=gd;
250 
251             if(a+b<mini)
252 
253             {
254 
255                 mini=a+b;
256 
257                 resa=a;
258 
259                 resb=b;
260 
261             }
262 
263         }
264 
265         return ;
266 
267     }
268 
269     for(int i=0;i<=num[dept];i++)
270 
271     {
272 
273         if(product>mini) return ;
274 
275         dfs(dept+1,product);
276 
277         product*=fac[dept];
278 
279     }
280 
281 }
282 
283  
284 
285  
286 
287 void Solve(LL n)
288 
289 {
290 
291     ct=0;
292 
293     Find(n,120);
294 
295     sort(fac,fac+ct);
296 
297     num[0]=1;
298 
299     int k=1;
300 
301     for(int i=1;i<ct;i++)
302 
303     {
304 
305         if(fac[i]==fac[i-1])
306 
307             num[k-1]++;
308 
309         else
310 
311         {
312 
313             num[k]=1;
314 
315             fac[k++]=fac[i];
316 
317         }
318 
319     }
320 
321     cnt=k;
322 
323     dfs(0,1);
324 
325     if(resa>resb) swap(resa,resb);
326 
327 }
328 
329  
330 
331 int main()
332 
333 {
334 
335     while(cin>>gd>>lm)
336 
337     {
338 
339         if(gd==lm)
340 
341         {
342 
343             printf("%llu %llu\n",gd,lm);
344 
345             continue;
346 
347         }
348 
349         mini=INF;
350 
351         key=lm/gd;
352 
353         Solve(key);
354 
355         printf("%llu %llu\n",resa,resb);
356 
357     }
358 
359     return 0;
360 
361 }

View Code