Hello 2019 Solution

A. Gennady and a Card Game

签到.

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

 char s[], t[];

 bool solve()
 {
     int flag = false;
     for (int i = ; i <= ; ++i)
     {
         scanf("%s", t);
         if (t[] == s[] || t[] == s[])
             flag = true;
     }
     return flag;
 }

 int main()
 {
     while (scanf("%s", s) != EOF) puts(solve() ? "YES" : "NO");
     return ;
 }    

B. Petr and a Combination Lock

二进制枚举

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

 int n, a[];
 bool solve()
 {
     for (int i = ; i < ( << n); ++i)
     {
         int res = ;
         for (int j = ; j <= n; ++j)
         {
             int vis = (i >> (j - )) & ;
             res += a[j] * (vis ?  : -);
         }
         if (res %  == ) return true;
     }
     return false;
 }

 int main()
 {
     while (scanf("%d", &n) != EOF)
     {
         for (int i = ; i <= n; ++i) scanf("%d", a + i);
         puts(solve() ? "YES" : "NO");
     }
     return ;
 }

C. Yuhao and a Parenthesis

Solved.

题意：

给出n个括号序列，求两两匹配成合法序列的最多对数

思路：

考虑单个括号序列最后一定可以化简成 ))) 或者 ((( 或者)))(((这三种形式

或者本身就是合法的

发现第三种)))(((不可能和别人两两匹配成合法序列

只需考虑))) 和 ((( 的配对以及本身就是合法序列的配对即可

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

 #define N 500010
 int n;
 int l[N], r[N], good;
 char s[N];

 int main()
 {
     while (scanf("%d", &n) != EOF)
     {
         memset(l, , sizeof l);
         memset(r, , sizeof r);
         good = ;
         for (int i = ; i <= n; ++i)
         {
             scanf("%s", s + );
             int len = strlen(s + );
             int left = , right = ;
             for (int i = ; i <= len; ++i)
             {
                 if (s[i] == '(') ++left;
                 else
                 {
                     if (left > ) --left;
                     else ++right;
                 }
             }
             if (left >  && right > ) continue;
             if (left ==  && right == ) ++good;
             else if (left == ) ++r[right];
             else ++l[left];
         }
         int res = ;
         for (int i = ; i <= ; ++i) res += min(l[i], r[i]);
         res += good / ;
         printf("%d\n", res);
     }
     return ;
 }

D. Makoto and a Blackboard

Upsolved.

题意：

$刚开始黑板上有一个n,我们假定此时在黑板上的数是v$

那么每次可以取$v的一个因数去替换这个数，求最后留下的数的期望$

思路：

我们假定$n一共有p个因数，以及dp[x][j] 表示进行n为x，并且进行j轮的期望$

易得转移方程

$dp[x][j] = \frac{\sum_{i = 1}^{i = p} dp[y][j - 1]}{p}$

那么很显然的一个递推就出来了，每次枚举n的每个因子，再枚举n的每个因子的每个因子，递推上去

T了，喵喵喵，(觉得个数会很少？

后来发现我们要求的只是 $dp[n][k]$

而且后面那部分的转移其实是可以拆的，拆成若干个因子期望的和/个数 再乘起来

那么我们质因子相同的放在一起做

这样就有前缀和性质

假设$n = x_1^{p_1} \cdot x_2 ^ {p_2} \cdots$

复杂度就是$O(p * k)$ 因为p不会太大

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

 #define ll long long
 #define N 10010
 #define pli pair <ll, int>
 const ll MOD = (ll)1e9 + ;
 ll n; int k;
 ll inv[N];

 vector <pli> getfact(ll n)
 {
     vector <pli> res;
     for (ll i = ; i * i <= n; ++i)
     {
         int need = ;
         while (n % i == )
         {
             ++need;
             n /= i;
         }
         if (need) res.emplace_back(i, need);
     }
     if (n != ) res.emplace_back(n, );
     return res;
 }

 ll f(ll x, ll p)
 {
     vector <ll> dp(p + , );
     dp[] = ;
     for (int i = ; i <= p; ++i)
         dp[i] = (dp[i - ] * x) % MOD;
     for (int rep = ; rep < k; ++rep)
     {
         for (int i = ; i <= p; ++i) dp[i] = (dp[i - ] + dp[i]) % MOD;
         for (int i = ; i <= p; ++i) dp[i] = (dp[i] * inv[i + ]) % MOD;
     }
     return dp[p];
 }

 int main()
 {
     inv[] = ;
     for (int i = ; i < N; ++i) inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
     while (scanf("%lld%d", &n, &k) != EOF)
     {
         ll ans = ;
         for (auto p : getfact(n))
             ans = (ans * f(p.first, p.second)) % MOD;
         printf("%lld\n", ans);
     }
     return ;
 }

F. Alex and a TV Show

Unsolved.

题意：

$有n个可重集，有四种操作$

$1 \;\;x\;\; v\;\; 表示将第\;x\;个集合设为\;\;{v}$

$2 \;\;x \;\;y\;\; z\;\; 表示将\;y\;和\;z\;两个集合并起来 赋给 \;\;x$

$3 \;\;x \;\;y \;\;z\;\; 表示将\;\;y\;\;和 \;\;z\;\;两个集合求乘积，乘积的定义为\;\; {gcd(a, b | a \in A, \; b \in B)} \;\;赋给\;\;x$

$4 \;\; x\;\; v\;\; 表示询问\;\;v\;\;在\;\;x\;\;中出现的次数 \;\;MOD \;\;2$

思路：

对每一个可重集维护$f[i]表示i的倍数出现的次数的奇偶性，用bitset维护$

那么

对于1操作，我们只需要根号暴力就可以了

对于2操作，本来是相加，但是只关心奇偶性的话就是半加就好，即异或

对于3操作，本来是相乘，对应的位运算就是与

对于4操作，反演一下

我们令$F[n] 表示n倍数的出现次数$

那么有$F[n] = \sum\limits_{n | d} f[d]$

反演之后便是

$f[n] = \sum\limits_{n | d}  \mu(\frac{d}{n}) \cdot F[d]$

这里的莫比乌斯函数1和-1没有区别，我们只关心奇偶性

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

 #define N 100010
 #define M 7010
 #define D 7000
 int n, q, mu[M];
 bitset <M> a[M], b[M], s[N];

 int main()
 {
     for (int i = ; i <= D; ++i) mu[i] = ;
     for (int i = ; i <= D; ++i) for (int j = i * i; j <= D; j += i * i) mu[j] = ;
     for (int i = ; i <= D; ++i) for (int j = i; j <= D; j += i)
     {
         a[j][i] = ;
         if (mu[j / i]) b[i][j] = ;
     }
     while (scanf("%d%d", &n, &q) != EOF)
     {
         for (int i = ; i <= n; ++i) s[i].reset();
         for (int i = , op, x, y, z, v; i <= q; ++i)
         {
             scanf("%d%d", &op, &x);
             if (op ==  || op == )
             {
                 scanf("%d", &v);
                 if (op == ) s[x] = a[v];
                 else putchar(((s[x] & b[v]).count() & ) + '');
             }
             else
             {
                 scanf("%d%d", &y, &z);
                 if (op == ) s[x] = s[y] ^ s[z];
                 else s[x] = s[y] & s[z];
             }
         }
         putchar('\n');
     }
     return ;
 }