两个数字的公因数总数 LARGE VALUES up to 10^12

Question

Inputs are two values 1 <= m , n <= 10^12 i don't know why my code is taking soo long for large values . time limit is 1 sec. please suggest me some critical modifications.

#include<iostream>
#include<algorithm>
using namespace std;

int main()
{
unsigned long long m,n,count=0;
cin >> m >> n;  
for (long long int i = 1; i <= ((min(m,n))/2)+1; i++) //i divided min(m,n) by 2 to make it efficient.
{

    if ((m%i == 0) && (n%i == 0))
    {
        count++;
    }

}
if (((n%m == 0) || (m%n == 0)) && (n!=m))
{
    cout << count << endl;
}

printf("%lld",count);  //cout<<count;

system("pause");
return 0;

}

Answer 1

Firstly

((min(m, n)) / 2) + 1

Is being calculated every iteration. But it's loop-invariant. In general loop invariant code can be calculated before the loop, and stored. It will add up, but there are obviously much better ways to improve things. I'll describe one below:

you can make this much faster by calculating how many common prime factors there are, and by dividing out any "found" primes as you go. eg if only one number is divisible by 5, and the other is not, you can divide that one by 5 and you still get the same answer for common factors. Divide m and n by any "found" numbers as you go through it. (but keep checking whether either is divisible by eg 2 and keep dividing before you go on).

eg if the two numbers are both divisible by 2, 3 and 5, then the number of ways those three primes can combine is 8 (2^3), treating the presence of each prime as a true/false thing. So each prime that occurs once multiplies the number of combos by 2.

If any of the primes occurs more than once, then it changes the equation slightly. eg if the two numbers are divisible by 4, 3, 5:

4 = 2^2, so you could have no "2s", 1 "2" or 2 "2s" in the combined factor, so the total combinations 3 x 2 x 2 = 12. So any prime that occurs "x" times, multiplies the total number of combos by "x+1".

So basically, you don't need to check for every actual factor, you just need to search for how many common prime factors there are, then work out how many combos that adds up to. Luckily you only need to store one value, "total_combos" and multiply it by the "x+1" value for each found number as you go.

And a handy thing is that you can divide out all primes as they're found, and you're guaranteed that the largest remaining prime to be found is no larger than the square root of the smallest remaining number out of m and n.

So to run you through how this would work, start with a copy of m and n, loop up to the sqrt of the min of those two (m and n will be reduced as the loop cycles through).

make a value "total_combos", which starts at 1.

Check for 2's first, find out how many common powers of 2 there are, add one to that number. Divide out ALL the 2's from m and n, even if they're not matched, because reducing down the number cuts the total amount you actually need to search. You count the 2's, add one, then multiply "total_combos" by that. Keep dividing m or n by two as long as either has a factor of 2 remaining.

Then check for 3's, find out how many common powers of 3 there are, add one, the multiply "total_combos" by that. Divide out any and all factors of 3 when you're doing this.

then check for 4's. Since 4 isn't prime and we got rid of all 2's already, there will be zero 4's. Add one to that = 1, then we times "total_combos" by 1, so it stays the same. We didn't need to check whether 4 was prime or not, the divisions we already did ensured it's ignored. Same for any power of 2.

then check for 5's. same deal as 2's and 3's. And so on. All the prime bases get divided out as you go, so whenever a value actually matches you can be sure it's a new prime.

stop the loop when it exceeds sqrt(max(m,n)) (EDITED: min is probably wrong there). But m and n here are the values that have had all the lower primes divided out, so it's much faster.

I hope this approach is helpful.

Answer 2

There is a better way to solve this problem. All you have to do is take the GCD of two numbers . Now any number won't divide m & n if they are greater than their GCD. So all you to do is that run a loop till the i<=Math.sqrt(GCD(m,n)) and check if the m%i==0 and n%i==0 only. It will save a lot of nanosecs.