2021杭电多校第零场 & 2021湘潭全国邀请赛 补题记录

比赛链接：Here

本场题目重现于 2021湘潭全国邀请赛

A - A+B Problem (签到)

根据题意处理即可

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    int _; for (cin >> _; _--;) {
        int a, b;
        cin >> a >> b;
        if (a + b <= 1023 and a + b >= -1024)cout << a + b << "\n";
        else if (a + b > 1023)cout << a + b - 2048 << "\n";
        else cout << a + b + 2048 << "\n";
    }
}

B - Binary Number

C - Calculate

D - Car

E - CCPC Strings （math）

思路来自 聆竹听风

题意：长度为 \(n\) 的只含有”C”或”P”的字符串共有 (\(2^n\))个，问：这所有(\(2^n\))个字符串中含有多少个”CCPC”（每一个”CCPC”之间不能相互重叠，即”CCPCCPC”中只能算(1)个”CCPC”）

---

假设所有长度为(\(n\))的”CP”字符串中互不重叠的”CCPC”的个数为(\(a_n\))

若认为可以相互重叠，可以通过计算贡献的方式进行计算

详细见 Here

const int mod = 1e9 + 7;
ll a[10];
ll qpow(ll a, ll b) {
    ll ans = 1;
    for (; b; b >>= 1, a = a * a % mod)
        if (b & 1) ans = (ans * a) % mod;
    return ans;
}
ll cal(ll x) {
    ll an = qpow(2, x - 1) * 64 % mod, a1 = qpow(2, (x - 1) % 6 + 6);
    ll inv63 = qpow(63, mod - 2);
    ll c = x % 6, z = (x - 1) % 6;
    if (c == 0) c += 6;
    ll s1 = c * qpow(2, z) % mod;
    return ((x * qpow(2, x + 5) % mod - 6 * (an - a1 + mod) % mod * inv63 % mod + mod) % mod - s1) % mod * inv63 % mod;
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    a[4] = 1, a[5] = 4, a[6] = 12;
    int _; for (cin >> _; _--;) {
        ll n; cin >> n;
        if (n < 7) cout << a[n] << "\n";
        else cout << (cal(n - 3) - cal(n - 6) + mod ) % mod << '\n';
    }
}

F - Control in a Matrix

G - Game （思维）

首先分析x−(10k−1)，减的这个数只能是9，99，999，…

99=9 * 11

999=9 * 111

999…=9 * K

这些数都是9的倍数,K是个奇数，所以对结果没有影响，因此我们可以将这个问题转化为每次减9

将这些数从小到大排序，每次先从最小的开始减

例如：19 10 29 不排序从第一个开始减最后减到的最小结果就是19 10 11（因为19-9=10，与第二个数字10有重复）

排序后的最小结果是1 10 11，这个在计算过程中不会出现少操作数，每个人都可以做到最佳选择

因为存在最后减完的结果一样，但是题目要求不可以出现重复的数字，所以需要再次处理

每次从最小的开始减，余数不为0的每次就让第一个减到0*9+余数，第二个减到1 * 9+余数…以此类推（如果余数为0，第一个减到1 * 9，第二个减到2 * 9，以此类推）

这里的避重（避免重复）操作数可以用前n项和实现

(余数为0) 例：9 18 27 化为最小结果（未对余数进行避重）分别需要的操作是 1 2 3次，总操作数=6

避重的话9应该减为1 * 9，18减为2 * 9，27减为3 * 9，需要的总操作数是1+2+3=6次

6-6=0，所以最后只能对这组数据进行0次操作。

(余数不为0)，与上类似，只是第一个数减到0 * 9+余数…

最后总结我们需要计算的就是：

一、将每个数化到最小一共需要多少次操作（一共能减多少次9，先不考虑余数相同）

二、统计余数相同的个数（对9取余 余数为0到8）

三、余数相同的数字，计算去重操作数

四、总操作数-避重操作数即为最后的操作数，如果为偶数，则B赢，反之，则A赢。

const int N = 1e6 + 10;
ll a[N], book[100]; // book 不要取太大，memset太花时间
int n;
int main() {
    //cin.tie(nullptr)->sync_with_stdio(false);
    while (~scanf("%d", &n) and n) {
        memset(book, 0, sizeof(book));
        for (int i = 0; i < n; ++i) scanf("%d", a + i);
        sort(a, a + n);
        int sum = 0;
        for (int i = 0; i < n; ++i) {
            int b = a[i] % 9;
            if (b == 0)b = 9;
            sum += (a[i] - b - book[b] * 9) / 9;
            book[b]++;
        }
        cout << "BA"[sum & 1] << "\n";
    }
}

H - Huge Directed Graph

I - Sequence

J - Stacks （Good）

很巧妙的图论搜索题，

把栈想成图中的点，根据操作将设定好的结构体左右端点相连。

最后判断情况输出即可

const int N = 1e5 + 10;
struct node {
    int l, r;
} q[N];

int idx, n, m, k;
vector<int>e[N];
int b[N];

void dfs(int u, int f) {
    for (int v : e[u]) {
        if (v == f)continue;
        b[++k] = v;
        dfs(v, u);
    }
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    while (cin >> n >> m) {
        idx = 0;
        for (int i = 1; i <= n; ++i) q[i].l = q[i].r = i, e[i].clear();

        while (m--) {
            int a, b;;
            cin >> a >> b;
            if (q[a].l and q[b].l) { // a,b
                e[q[a].l].push_back(q[b].l);
                e[q[b].l].push_back(q[a].l);
                q[b].l = q[a].r;
                q[a].l = q[a].r = 0;
            } else if (q[a].l and !q[b].l) { // a,b
                q[b].l = q[a].r;
                q[b].r = q[a].l;
                q[a].l = q[a].r = 0;
            }
        }

        for (int i = 1; i <= n; ++i) {
            if (!q[i].l)cout << "0\n";
            else {
                k = 0;
                dfs(q[i].l, -1);
                cout << k + 1 << " " << q[i].l;
                for (int i = 1; i <= k; ++i) cout << " " << b[i];
                cout << "\n";
            }
        }
    }
}

K - Substring （滑动窗口）

滑动窗口，开一个队列数组存出现过的字母下标

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    int k; string s;
    while (cin >> k >> s) {
        queue<int>a[26];
        int n = s.length();
        int i = 0, j = 1;
        a[s[0] - 'a'].push(0);
        int Len = 1;
        while (i <= j and j < n) {
            int t = s[j] - 'a';
            a[t].push(j);
            if (a[t].size() <= k)Len = max(Len, j - i + 1);
            else {
                for (int k = i; k < a[t].front(); ++k) a[s[k] - 'a'].pop();
                i = a[t].front() + 1;
                a[t].pop();
            }
            j++;
        }
        cout << Len << '\n';
    }
}

L - Swap