CF 1033 D. Divisors

D. Divisors

http://codeforces.com/contest/1033/problem/D

题意：

　　给n个（n<=500）个数，（$a_i <= 2 \times 10 ^ {18}$），每个数的因数个数在[3,5]内。$a = \prod\limits_{i=1}^na_i$，求a的因数个数。

分析：

　　首先有一个结论：一个数x的质因数分解后为：$x = p_1^{a_1}p_2^{a_2}...p_k^{a_k}$ 那么它的因数个数就是 $(a_1 + 1) \times (a_2 + 1) \times ... \times (a_k + 1)$。

　　于是这道题就可以求出每个质因数的个数，然后将指数+1相乘即可。

　　但是$a_i$太大了，无法直接求质因数。

　　因为每个数的因数个数在[3,5]范围内，所以根据上面的结论，可以知道每个数的质因数分解只有四种形式：$pq, p^2, p^3,p^4$。后三种直接二分就能算出其质因数，用map记录每个质因数的指数。

　　对于第一种，直接求质因数是不可能的了，考虑能否不求质因数，而计算答案。首先对于所有数二分，如果不能分成后三种，那么将其记录到b数组中。b中的一个数拆成第一种形式后，p和q，在map都没出现过，那么我们可以知道它的贡献就是(2*2)了（不考虑后面的）。如果p和q中有一个出现过了，我们必须要合并他们的幂。

　　如何合并幂：枚举b[i]，枚举a数组中的所有数，求gcd，如果1<gcd<b[i]，那么可以说明b[i]和a[j]分解后的都有gcd，（b[i]=pq，gcd=p或者q）。

　　对于剩下的数，每一个分解后的质数都是还未出现过，直接计算答案。

代码：

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<cmath>
 #include<iostream>
 #include<cctype>
 #include<set>
 #include<vector>
 #include<queue>
 #include<map>
 #define fi(s) freopen(s,"r",stdin);
 #define fo(s) freopen(s,"w",stdout);
 using namespace std;
 typedef long long LL;

 inline LL read() {
     LL x=,f=;char ch=getchar();for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-;
     for(;isdigit(ch);ch=getchar())x=x*+ch-'';return x*f;
 }

 const int N = ;
 const int mod = ;
 const LL INF = 9e18;

 LL a[N], b[N], c[N];
 map<LL,int> f;
 LL Sqrt(LL x,int k) {
     LL l = , r; // 虽然现在的l,r在int范围内，但是也要开longlong!!!!!
     if (k == ) r = ;
      if (k == ) r = ;
      if (k == ) r = ;
     while (l <= r) {
         LL mid = (l + r) >> ;
         LL t = ;
         for (int i=; i<=k; ++i) t = 1ll * t * mid;
         if (t == x) return mid;
         else if (t > x) r = mid - ;
         else l = mid + ;
     }
     return -;
 }
 LL gcd(LL a,LL b) {
     return b ==  ? a : gcd(b, a % b);
 }
 int main() {
     int n = read();
     for (int i=; i<=n; ++i) a[i] = read();

     for (int i=; i<=n; ++i) {
         bool flag = ;
         for (int k=; k>=; --k) { // 从大到小！！！
             LL p = Sqrt(a[i], k);
             if (p != -) { f[p] += k; flag = ; break; }
         }
         if (!flag) b[i] = a[i];
     }
     for (int i=; i<=n; ++i) {
         if (!b[i]) continue;
         bool flag = ;
         for (int j=; j<=n; ++j) {
             if (i == j) continue;
             LL d = gcd(b[i], a[j]);
             if (d !=  && d != b[i]) {
                 flag = ; f[d] ++; f[b[i] / d] ++; break;
             }
         }
         if (!flag) c[i] = b[i];
     }
     LL ans = ;
     for (int i=; i<=n; ++i) {
         if (!c[i]) continue;
         LL cnt = ;
         for (int j=; j<=n; ++j)
             if (i != j && c[i] == c[j]) cnt ++, c[j] = ;
         cnt = cnt * cnt % mod;
         ans = ans * cnt % mod;
     }
     map<LL,int> :: iterator it;
      for (it=f.begin(); it!=f.end(); it++)
          ans = (ans * (it->second + )) % mod;
 //    for (auto p: f) ans = (ans * (p.second + 1)) % mod;
     cout << ans;
      fflush(stdout);
     return ;
 }