Codeforces Edu Round 52 A-E

A. Vasya and Chocolate

模拟题。数据会爆$int$，要开$long$ $long$

#include <iostream>

#include <cstdio>

using namespace std;

typedef long long LL;

int main(){

    int T; scanf("%d", &T);

    while(T--){

        LL s, a, b, c;

        scanf("%lld%lld%lld%lld", &s, &a, &b, &c);

        LL buy = s / c, free = buy / a * b;

        printf("%lld\n", buy + free);

    }

    return 0;

}

B. Vasya and Isolated Vertices

考虑最小时，两两连边，答案为$max(n - 2 * m, 0)$

考虑最大时，除了$m$为$1或0$特判以外，每次尝试用最多的边拓展一个点为不孤立的，则可以放$now - 1$条边连向之前所有的边。

#include <cstdio>

#include <iostream>

#include <cmath>

using namespace std;

typedef long long LL;

LL n, m;

int main(){

    cin >> n >> m;

    cout << max(n - 2 * m, 0ll) << " ";

    if(m == 0) printf("%lld\n", n);

    else if(m == 1) printf("%lld\n", n - 2);

    else{

        int now = 2;

        while(m - now + 1 > 0 && now < n) m -= (now - 1), now++;

        printf("%lld\n", n - now);

    }

    return 0;

}

C. Make It Equal

我太弱了，只想到了$O(nlogn)$的做法...就是用树状数组维护前缀和，就能用$O(logn)$的时间计算出代价，然后弄一个指针从大往小搜就可以了...

#include <cstdio>

#include <iostream>

#include <cmath>

#include <limits.h>

typedef long long LL;

using namespace std;

const int N = 200010;

int n, k, a[N], cnt[N], ans = 0, maxn = -1, minn = INT_MAX;

LL c[N];

void add(int x, LL k){

    for(; x <= maxn; x += x & -x) c[x] += k;

}

LL ask(int x){

    LL res = 0;

    for(; x; x -= x & -x) res += c[x];

    return res;

}

LL inline get(int x){

    return ask(maxn) - ask(x - 1);

}

int main(){

    scanf("%d%d", &n, &k);

    for(int i = 1; i <= n; i++)

        scanf("%d", a + i), cnt[a[i]]++, maxn = max(maxn, a[i]), minn = min(minn, a[i]);

    for(int i = maxn; i >= 1; i--)

        add(i, (LL)cnt[i] * i);

    for(int i = maxn; i >= 1; i--)

        cnt[i] += cnt[i + 1];

    int i = maxn - 1;

    while(i >= minn){

        ans++;

        while(i - 1 >= minn && get(i) - (LL)(i - 1) * cnt[i] <= k) i--;

        add(i, (LL)i * (cnt[i + 1]) - get(i + 1));

        i--;

    }

    printf("%d\n", ans);

    return 0;

}

其实可以在指针从上往下跳的过程中处理后缀和，所以可以用$O(n)$的时间解决辣：

#include <cstdio>

#include <iostream>

#include <cmath>

#include <limits.h>

typedef long long LL;

using namespace std;

const int N = 200010;

int n, k, a[N], cnt[N], po[N], ans = 0, maxn = -1, minn = INT_MAX;

LL c[N];

int main(){

    scanf("%d%d", &n, &k);

    for(int i = 1; i <= n; i++)

        scanf("%d", a + i), po[a[i]]++, cnt[a[i]]++, maxn = max(maxn, a[i]), minn = min(minn, a[i]);

    for(int i = maxn; i >= 1; i--)

        cnt[i] += cnt[i + 1];

    int i = maxn - 1;

    c[maxn] = (LL)maxn * po[maxn];

    while(i >= minn){

        ans++;

        c[i] = c[i + 1] + (LL)i * po[i];

        while(i - 1 >= minn && c[i] - (LL)(i - 1) * cnt[i] <= k)

            i--, c[i] = c[i + 1] + (LL)i * po[i];;

        c[i] += (LL)i * (cnt[i + 1]) - c[i + 1];

        i--;

    }

    printf("%d\n", ans);

    return 0;

}

D. Three Pieces

$pair<int, int>$自带比较函数，所以省了不少功夫。写了一个优先队列$bfs$就过惹...

一共会有$3 *N ^ 4 $个状态，每次状态扩展最多要扩展$4 * N$级别，其实还会少。

总共复杂度为$O(12 * N ^ 5)$，不会$TLE$。

#include <iostream>

#include <cstdio>

#include <queue>

#include <cstring>

using namespace std;

typedef pair<int, int> PII;

const int N = 15;

int n, a[N][N];

PII num[N * N];

//0: 车、1: 马： 2、象

int dx[3][8] = {

    {1, -1, 0, 0},

    {1, 1, -1, -1, -2, -2, 2, 2},

    {1, 1, -1, -1},

};

int dy[3][8] = {

    {0, 0, 1, -1},

    {2, -2, 2, -2, 1, -1, 1, -1},

    {1, -1, 1, -1},

};

int size[3] = {4, 8, 4};

int ne[3] = {N, 1, N};

PII step[N][N][N * N][3];

struct Node{

    int x, y, k, m, t, c;

};

bool operator < (const Node &x, const Node &y){

    return x.t == y.t ? x.c > y.c : x.t > y.t;

}

bool inline check(int x, int y){

    return x >= 1 && x <= n && y >= 1 && y <= n;

}

PII bfs(){

    priority_queue<Node> q;

    for(int i = 0; i < 3; i++){

        q.push((Node){ num[1].first, num[1].second, 1, i, 0, 0});

        step[num[1].first][num[1].second][0][i] = make_pair(0, 0);

    }

    while(!q.empty()){

        Node u = q.top(); q.pop();

        if(u.k >= n * n){

            return make_pair(u.t, u.c);

        }

        for(int i = 0; i < size[u.m]; i++){

            for(int j = 1; j <= ne[u.m]; j++){

                int nx = u.x + dx[u.m][i] * j, ny = u.y + dy[u.m][i] * j;

                int nm = u.m, nt = u.t + 1, nc = u.c;

                int nk = (num[u.k + 1] == make_pair(nx, ny)) ? u.k + 1 : u.k;

                PII now = make_pair(nt, nc);

                if(!check(nx, ny)) break;

                if(now < step[nx][ny][nk][nm]){

                    step[nx][ny][nk][nm] = now;

                    q.push((Node){nx, ny, nk, nm, nt, nc});

                }

            }

        }

        for(int i = 0; i < 3; i++){

            if(i == u.m) continue;

            int nx = u.x, ny = u.y;

            int nm = i, nt = u.t + 1, nc = u.c + 1;

            int nk = u.k;

            PII now = make_pair(nt, nc);

            if(!check(nx, ny)) break;

            if(now < step[nx][ny][nk][nm]){

                step[nx][ny][nk][nm] = now;

                q.push((Node){nx, ny, nk, nm, nt, nc});

            }

        }

    }

    return make_pair(-1, -1);

}

int main(){

    memset(step, 0x3f, sizeof step);

    scanf("%d", &n);

    ne[0] = ne[2] = n;

    for(int i = 1; i <= n; i++)

        for(int j = 1; j <= n; j++)

            scanf("%d", &a[i][j]), num[a[i][j]] = make_pair(i, j);

    PII res = bfs();

    printf("%d %d\n", res.first, res.second);

    return 0;

}

E. Side Transmutations

组合数问题，我肯定是不会的...

设$A$为字符集合的长度。

对于每一段 $ [b_{i - 1} + 1,b_i] $ $ (1 <= i <= m)$

设这一段的长度$len = b[i] - (b[i - 1] + 1) + 1 = b[i] - b[i - 1]$

它有$A ^ {len} $种不同的选择方案：

翻过去不同，那么对应过去就有$A ^ {len} - 1$ 种方案（不包括翻过去相同那种），由于可能算上等价操作，他俩算一个，所以它的贡献为 $\frac{A ^ {len} * (A ^ {len} - 1)}{2}$
翻过去相同，每种方案对应过去式唯一的，所以为$A ^ {len}$。

这两种方案相加再$*$入$ans$中即可。

对于$[b_m + 1, n - b_m]$这段，选不选都不会造成重复，对答案的贡献是：

$A ^ {n - b_m - (b _m + 1) + 1} = A ^ {n - 2 * b_m }$

#include <iostream>

#include <cstdio>

using namespace std;

typedef long long LL;

const int MOD = 998244353;

const int N = 200010;

int n, m, A, b[N];

int power(int a, int b){

    int res = 1;

    while(b){

        if(b & 1) res = (LL)res * a % MOD;

        a = (LL)a * a % MOD;

        b >>= 1;

    }

    return res;

}

int main(){

    cin >> n >> m >> A;

    for(int i = 1; i <= m; i++) scanf("%d", b + i);

    LL ans = 1;

    for(int i = 1; i <= m; i++){

        LL now = power(A, b[i] - b[i - 1]);

        ans = (ans * ((now + now * (now - 1) / 2) % MOD)) % MOD;

    }

    ans = (ans * power(A, (n - 2 * b[m]))) % MOD;

    cout << ans;

    return 0;

}