2019 Multi-University Training Contest 7

无fuck说。

1001 - A + B = C

分析：首先把c末尾的0去掉，那么只剩下两种情况，要么a后面加0，要么b后面加0，枚举这两种情况。

当a和b的长度确定的时候，c的长度也确定了（ab最大值或者再加1，考虑进位），然后直接hash判断两者的值是否相同即可。

注意把c末尾的0去掉的，最后应该加上。

#include "bits/stdc++.h"

using namespace std;
const long long mod1 = 1e9 + 9;
const long long mod2 = 1e9 + 7;
char a[100004], b[100004], c[100004];
long long pre1[300014], pre2[300014];

void MOD(long long &x, long long mod) {
    if (x >= mod)x %= mod;
}

int main() {
    int t;
    cin >> t;
    pre1[0] = pre2[0] = 1;
    for (int i = 1; i < 300014; ++i) {
        pre1[i] = pre1[i - 1] * 10 % mod1;
        pre2[i] = pre2[i - 1] * 10 % mod2;
    }
    while (t--) {
        scanf("%s%s%s", a, b, c);
        int lena = strlen(a), lenb = strlen(b), lenc = strlen(c);
        long long basea1 = 0, basea2 = 0, baseb1 = 0, baseb2 = 0, basec1 = 0, basec2 = 0;
        int cnt = 0;
        while (c[lenc - 1] == '0') {
            lenc--;
            cnt++;
        }
        for (int i = 0; i < lena; ++i) {
            basea1 = basea1 * 10 + a[i] - '0';
            basea2 = basea2 * 10 + a[i] - '0';
            MOD(basea1, mod1);
            MOD(basea2, mod2);
        }
        for (int i = 0; i < lenb; ++i) {
            baseb1 = baseb1 * 10 + b[i] - '0';
            baseb2 = baseb2 * 10 + b[i] - '0';
            MOD(baseb1, mod1);
            MOD(baseb2, mod2);
        }
        for (int i = 0; i < lenc; ++i) {
            basec1 = basec1 * 10 + c[i] - '0';
            basec2 = basec2 * 10 + c[i] - '0';
            MOD(basec1, mod1);
            MOD(basec2, mod2);
        }
        long long temp1 = basea1, temp2 = basea2;
        int x = -1, y, z;
        for (int i = 0; i < 100004; ++i) {
            int len = max(lena + i, lenb);
            long long res1 = (temp1 + baseb1) % mod1;
            long long res2 = (temp2 + baseb2) % mod2;
            if (len >= lenc - 1){
                for (int j = 0; j < 2; ++j) {
                    long long resc1 = basec1 * pre1[len - lenc + j] % mod1;
                    long long resc2 = basec2 * pre2[len - lenc + j] % mod2;
                    if (resc1 == res1 && resc2 == res2) {
                        x = i, y = 0, z = len - lenc + j - cnt;
                        break;
                    }
                }
            }

            temp1 = temp1 * 10 % mod1;
            temp2 = temp2 * 10 % mod2;
        }
        temp1 = baseb1, temp2 = baseb2;
        for (int i = 0; i < 100004 && (x == -1); ++i) {
            int len = max(lenb + i, lena);
            long long res1 = (temp1 + basea1) % mod1;
            long long res2 = (temp2 + basea2) % mod2;
            if (len >= lenc - 1){
                for (int j = 0; j < 2; ++j) {
                    long long resc1 = basec1 * pre1[len - lenc + j] % mod1;
                    long long resc2 = basec2 * pre2[len - lenc + j] % mod2;
                    if (resc1 == res1 && resc2 == res2) {
                        x = 0, y = i, z = len - lenc + j - cnt;
                        break;
                    }
                }
            }
            temp1 = temp1 * 10 % mod1;
            temp2 = temp2 * 10 % mod2;
        }
        if (z < 0) {
            x -= z, y -= z, z = 0;
        }
        if (x == -1)puts("-1");
        else printf("%d %d %d\n", x, y, z);
    }
}

1006 - Final Exam

分析：雨露均沾复习法。考虑最极端的情况，在所有科目中有K-1个题目是0分白给，剩下n-k+1个中最小值是m/(n-k+1)。那么只需要每个都复习m/(n-k+1)+1就可以了，然而这并不是最优解。

令d = m/(n-k+1)+1，即每道题的复习时间，那么总复习时间是n*d。OK还是考虑极端的情况，有K-1道题0分白给，剩下n-k+1道题平分分数，那么有一部分是m/(n-k+1)，个数设为x，而另一部分是m/(n-k+1)+1，个数设为y。此时我们只需要保证这n-k+1道中，至少有一道会做就可以了，那么只要这n-k+1道中有y+1道是m/(n-k+1)+1就可以了，即有x-1道是m/(n-k+1)，即少了x-1个小时。那么我们就可以少复习（n-k+1)*d - m - 1。

#include "bits/stdc++.h"
using namespace std;
int main(){
    int t;
    cin>>t;
    while(t--){
        long long n,m,k;
        scanf("%lld%lld%lld",&n,&m,&k);
        long long d = m / (n - k + 1) + 1;
        long long ans = n * d;
        long long x = (n - k + 1) * d - m;
        ans -= x - 1;
        cout<<ans<<endl;
    }
}

1010 - Just Repeat

分析：对于不是双方同时拥有的类型的牌，是不会对自己或对方造成影响，所以最后出。

对于双方同时拥有的牌，自己有a张，对手有b张，那么如果自己选了这张牌的结果是，对方少了b张，反过来，如果对手选了这张牌，结果是自己少了a张牌，中间的差值就是a+b。所以显而易见的，对a+b进行排序，每次优先取最大的，然后最后比较双方的牌的数量。

#include "bits/stdc++.h"

using namespace std;

unsigned long long rng(unsigned long long &k1, unsigned long long &k2) {
    unsigned long long k3 = k1, k4 = k2;
    k1 = k4;
    k3 ^= k3 << 23;
    k2 = k3 ^ k4 ^ (k3 >> 17) ^ (k4 >> 26);
    return k2 + k4;
}

unsigned long long a[100004], b[100004];

struct node {
    int sum, a, b;

    bool friend operator<(node a, node b) {
        return a.sum < b.sum;
    }
};

int main() {
    int n, m, p;
    int t;
    cin >> t;
    while (t--) {
        scanf("%d%d%d", &n, &m, &p);
        if (p == 1) {
            for (int i = 1; i <= n; ++i) {
                scanf("%llu", &a[i]);
            }
            for (int i = 1; i <= m; ++i) {
                scanf("%llu", &b[i]);
            }
        } else {
            unsigned long long k1, k2, mod;
            scanf("%llu%llu%llu", &k1, &k2, &mod);
            for (int i = 1; i <= n; ++i) {
                a[i] = rng(k1, k2) % mod;
            }
            scanf("%llu%llu%llu", &k1, &k2, &mod);
            for (int i = 1; i <= m; ++i) {
                b[i] = rng(k1, k2) % mod;
            }
        }
        sort(a + 1, a + 1 + n);
        sort(b + 1, b + 1 + m);
        int px, py, cx, cy;
        px = py = 1;
        cx = cy = 1;
        int sumn = n, summ = m;
        priority_queue<node> q;
        while (1) {
            if (a[px] == b[py]) {
                while (px + 1 <= n && a[px] == a[px + 1]) {
                    px++;
                    cx++;
                }
                while (py + 1 <= m && b[py] == b[py + 1]) {
                    py++;
                    cy++;
                }
                q.push({cx + cy, cx, cy});
                sumn -= cx;
                summ -= cy;
                px++;
                py++;
                cx = cy = 1;
            } else if (a[px] < b[py])px++;
            else py++;
            if (px == n + 1 || py == m + 1)break;
        }
        int now = 0;
        while (!q.empty()) {
            node t = q.top();
            q.pop();
            if (!now) {
                sumn += t.a;
            } else summ += t.b;
            now ^= 1;
        }
        if (sumn > summ)puts("Cuber QQ");
        else puts("Quber CC");
    }
}

1011 - Kejin Player

分析：dp[i]表示i-1到i的期望花费。容易得到当概率为p时，期望尝试1/p次成功，第一次的花费是a[i-1]，之后的花费是x[i-1]到i-1的花费加a[i-1]。那么转移方程：dp[i]=1/p * a[i-1] + (1/p-1)*(pre[i-1]-pre[x[i-1]])，其中pre表示dp的前缀和。

#include "bits/stdc++.h"

using namespace std;
const int mod = 1e9 + 7;
long long dp[500004];
long long pre[500004];
int r[500004], s[500004], x[500004], a[500004];

inline long long MOD(long long a) {
    while (a >= mod)a -= mod;
    while (a < 0)a += mod;
    return a;
}

long long qk(long long a, long long n) {
    long long res = 1;
    while (n) {
        if (n & 1)res = res * a % mod;
        n >>= 1;
        a = a * a % mod;
    }
    return res;
}

int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        int n, q;
        scanf("%d%d", &n, &q);
        for (int i = 1; i <= n; ++i) {
            scanf("%d%d%d%d", &r[i], &s[i], &x[i], &a[i]);
            dp[i] = 0;
        }
        for (int i = 2; i <= n + 1; ++i) {
            long long times = 1LL * s[i - 1] * qk(r[i - 1], mod - 2) % mod;
            dp[i] = MOD(pre[i - 1] - pre[x[i - 1]] + a[i - 1]) * times % mod;
            dp[i] = MOD(dp[i] - pre[i - 1] + pre[x[i - 1]]);
            pre[i] = MOD(pre[i - 1] + dp[i]);
        }
        while (q--) {
            int l, r;
            scanf("%d%d", &l, &r);
            printf("%lld\n", MOD(pre[r] - pre[l]));
        }
    }
}