Atcoder CADDi 2018 Solution

C - Product and GCD

Solved.

题意：

给出$n个数$的乘积，求$这n个数$的最大的可能是GCD

思路：

分解质因子，那么$每个质因子的贡献就是其质因子个数/ n的乘积$

 #include <bits/stdc++.h>
 using namespace std;

 #define ll long long
 ll n, p;

 int main()
 {
     while (scanf("%lld%lld", &n, &p) != EOF)
     {
         if (n == )
         {
             printf("%lld\n", p);
             continue;
         }
         ll res = ;
         for (ll i = ; i * i <= p; ++i)
         {
             ll tmp = ;
             while (p % i == )
             {
                 ++tmp;
                 p /= i;
             }
             while (tmp >= n)
             {
                 tmp -= n;
                 res *= i;
             }
         }
         printf("%lld\n", res);
     }
     return ;
 }

D - Harlequin

Solved.

题意：

有$n种颜色的苹果，每种颜色有a_i个，每次可以选择若干个不同颜色的苹果拿掉，轮流拿，谁不能拿谁输$

问 先手胜还是后手胜

思路：

必败局面是当前场上所有颜色的苹果都是偶数个，这样的话，你拿什么，对方跟着你拿，对方肯定胜利

那么必胜局面就是当前场上存在有若干种奇数个颜色的苹果，取掉这些苹果，转换成必败局面留给对方就好了

简单判一判就没了

 #include <bits/stdc++.h>
 using namespace std;

 int n, x;

 int main()
 {
     while (scanf("%d", &n) != EOF)
     {
         x = ;
         for (int i = , y; i <= n; ++i)
         {
             scanf("%d", &y);
             x += y & ;
         }
         puts(x ? "first" : "second");
     }
     return ;
 }

E - Negative Doubling

Upsolved.

题意：

给出n个数，对每个数的操作只有 $\cdot -2$ ，求最少多少次操作使得序列变成非下降序列

思路：

我们考虑序列中如果存在正数和负数，那么必然存在一个界限，左边全是负数，右边全是正数

那么我们可以预处理出

$f[i] 表示 使得从i开始是一个非下降序列的最小花费$

$g[i]表示 i以及i以前是一个非下降序列，且全都是负数的最小花费$

维护的过程可以用一个队列

刚开始以为如果当前数比之前的数不满足大小关系，后面的数或者前面的数全都要动

但实际上并不是这样，

比如说

5 3 4 1000000

推到5的时候 只有 3 和 4 要改变

 #include <bits/stdc++.h>
 using namespace std;

 #define ll long long
 #define N 200010
 #define pii pair <int, int>
 int n;
 ll a[N], b[N], f[N], g[N], lazy; 

 void Run()
 {
     while (scanf("%d", &n) != EOF)
     {
         for (int i = ; i <= n; ++i) scanf("%lld", a + i);
         queue <pii> q;
         f[n] = ;
         for (int i = n - ; i >= ; --i)
         {
             f[i] = f[i + ];
             if (a[i] > a[i + ])
             {
                 ll tmp = a[i + ];
                 int cnt = ;
                 while (tmp < a[i])
                 {
                     tmp *= ;
                     cnt += ;
                 }
                 int x = i;
                 while (!q.empty())
                 {
                     f[i] += 1ll * (q.front().second - x) * cnt;
                     if (q.front().first <= cnt) cnt -= q.front().first;
                     else
                     {
                         pii tmpp = q.front();
                         tmpp.first -= cnt;
                         cnt = ;
                         q.pop();
                         q.push(tmpp);
                         break;
                     }
                     x = q.front().second;
                     q.pop();
                 }
                 f[i] += 1ll * (n - x) * cnt;
             }
             else
             {
                 ll tmp = a[i];
                 int cnt = ;
                 while (tmp *  <= a[i + ])
                 {
                     tmp *= ;
                     cnt += ;
                 }
                 if (cnt) q.push(pii(cnt, i));
             }
         }
         while (!q.empty()) q.pop();
         g[] = ;
         b[] = -a[];
         for (int i = ; i <= n; ++i)
         {
             g[i] = g[i - ] + ;
             b[i] = -a[i];
             if (b[i] < b[i - ])
             {
                 ll tmp = b[i - ];
                 int cnt = ;
                 while (tmp > b[i])
                 {
                     tmp *= ;
                     cnt += ;
                 }
                 int x = i;
                 while (!q.empty())
                 {
                     g[i] += 1ll * (x - q.front().second) * cnt;
                     if (q.front().first <= cnt) cnt -= q.front().first;
                     else
                     {
                         pii tmpp = q.front();
                         q.pop();
                         tmpp.first -= cnt;
                         cnt = ;
                         q.push(tmpp);
                         break;
                     }
                     x = q.front().second;
                     q.pop();
                 }
                 g[i] += 1ll * (x - ) * cnt;
             }
             else
             {
                 ll tmp = b[i];
                 int cnt = ;
                 while (tmp *  >= b[i - ])
                 {
                     tmp *= ;
                     cnt += ;
                 }
                 if (cnt) q.push(pii(cnt, i));
             }
         }
         ll res = min(f[], g[n]);
         for (int i = ; i < n; ++i) res = min(res, g[i] + f[i + ]);
         printf("%lld\n", res);
     }
 }

 int main()
 {
     #ifdef LOCAL
         freopen("Test.in", "r", stdin);
     #endif 

     Run();
     return ;
 }