Hello 2019 Solution

A. Gennady and a Card Game

签到.

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

char s[5], t[5];

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

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

B. Petr and a Combination Lock

二进制枚举

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

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

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

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, 0, sizeof l);
        memset(r, 0, sizeof r);
        good = 0;
        for (int i = 1; i <= n; ++i)
        {
            scanf("%s", s + 1);
            int len = strlen(s + 1);
            int left = 0, right = 0;
            for (int i = 1; i <= len; ++i)
            {
                if (s[i] == '(') ++left;
                else
                {
                    if (left > 0) --left;
                    else ++right;
                }
            }
            if (left > 0 && right > 0) continue;
            if (left == 0 && right == 0) ++good;
            else if (left == 0) ++r[right];
            else ++l[left];
        }
        int res = 0;
        for (int i = 1; i <= 500000; ++i) res += min(l[i], r[i]);
        res += good / 2;
        printf("%d
", res);
    }
    return 0;
}

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 + 7;
ll n; int k;
ll inv[N];

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

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

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

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] = sumlimits_{n | d} f[d]$

反演之后便是

$f[n] = sumlimits_{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 = 1; i <= D; ++i) mu[i] = 1;
    for (int i = 2; i <= D; ++i) for (int j = i * i; j <= D; j += i * i) mu[j] = 0;
    for (int i = 1; i <= D; ++i) for (int j = i; j <= D; j += i)
    {
        a[j][i] = 1;
        if (mu[j / i]) b[i][j] = 1;
    }        
    while (scanf("%d%d", &n, &q) != EOF)
    {
        for (int i = 1; i <= n; ++i) s[i].reset();
        for (int i = 1, op, x, y, z, v; i <= q; ++i)
        {
            scanf("%d%d", &op, &x);
            if (op == 1 || op == 4)
            {
                scanf("%d", &v);
                if (op == 1) s[x] = a[v];
                else putchar(((s[x] & b[v]).count() & 1) + '0');
            }
            else
            {
                scanf("%d%d", &y, &z);
                if (op == 2) s[x] = s[y] ^ s[z];
                else s[x] = s[y] & s[z]; 
            }
        }
        putchar('
');
    }    
    return 0;
}