[CF]Round510

由于我的codeforces的帐号登不上，所以我错过了这场比赛，只好赛后再抄题解自己做。

A Benches

最大的情况就是所有人都挤在那个人最多的长椅上，最小的情况是所有人尽量平均的坐。

#include <cstdio>
#include <cstring>
#include <algorithm>

const int N = 110;

int a[N], n, m, mx; 

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &a[i]);
        mx = std::max(a[i], mx);
    }
    int ansb = mx + m, ansa = 0;
    for (int i = 1; i <= n; ++i) {
        m -= mx - a[i];
    }
    if (m < 0) ansa = mx;
    else ansa = mx + m / n + (m%n != 0);
    printf("%d %d\n", ansa, ansb);
    return 0;
}

提交次数：\(1\)

B Vitamins

这个题直接DP，把有哪几种维他命状压一下就行。

#include <cstdio>
#include <cstring>
#include <algorithm>

const int N = 1010;

int V[N];
int n, c[N], p[N];
int f[10];

int main() {
    V['A'] = 1; V['B'] = 2; V['C'] = 4;
    scanf("%d", &n);
    char s[5];
    for (int i = 1; i <= n; ++i) {
        scanf("%d%s", &p[i], s);
        int len = strlen(s);
        for (int j = 0; j < len; ++j) c[i] |= V[s[j]];
    }
    memset(f, 0x3f, sizeof f);
    f[0] = 0;
    for (int i = 1; i <= n; ++i) {
        for (int S = 7; S >= 0; --S) if (f[S] < 0x3f3f3f3f) {
            f[S|c[i]] = std::min(f[S|c[i]], f[S] + p[i]);
        }
    }
    if (f[7] == 0x3f3f3f3f) puts("-1");
    else printf("%d\n", f[7]);
    return 0;
}

提交次数：\(1\)

C Array Product

这个也是一个简单的构造题，贪心的做就行，不要忘记只能删除一个点。

删正数肯定是不优的。如果有偶数个负数，乘起来就行，如果有奇数个负数，将绝对值最小的负数和0乘起来（如果没有0那就直接删），然后把所有0乘起来删掉（如果就只剩一个0了那就不能删）。

最后把所有数乘起来就行。

#include <cstdio>
#include <cstring>
#include <algorithm>

const int N = 2e5 + 10;

int a[N], n, m, mx = 0, del[N], tot, posi, nega, zero;
int ls[3][N]; 

int main() {
    scanf("%d", &n);
    a[0] = -0x3f3f3f3f;
    for (int i = 1; i <= n; ++i) {
        scanf("%d", &a[i]);
        if (a[i] == 0) {
            ls[1][++zero] = i;
        } else if (a[i] < 0 ) {
            ls[0][++nega] = i;
            if (a[i] > a[mx]) mx = i;
        } else {
            ls[2][++posi] = i;
        }
    }
    if (nega%2 != 0 && zero > 0) {
        printf("1 %d %d\n", mx, ls[1][1]);
        del[mx] = 1;
        tot++;
    } else if (nega%2 != 0 && zero == 0) {
        printf("2 %d\n", mx);
        del[mx] = 1;
        tot++;
    }

    if (zero > 0) {
        while (zero > 1 && tot < n-2) {
            printf("1 %d %d\n", ls[1][zero], ls[1][zero-1]);
            del[ls[1][zero]] = 1;
            zero--;
            tot++;
        }
        if (tot < n-1) {
            printf("2 %d\n", ls[1][1]);
            tot++;
            del[ls[1][1]] = 1;
        }
    }
    int i = 1, j;
    while (del[i]) i++;
    j = i+1;
    while (tot < n-1) {
        while (del[j]) j++;
        printf("1 %d %d\n", i, j);
        i = j;
        j = i+1;
        tot++;
    }
    return 0;
}

提交次数：\(3\)（没看到只能删一次和少处理了一个情况）。

D Petya and Array

求区间和一定要求前缀和，然后问题就转化成了求\(\displaystyle\sum_{l}\displaystyle\sum_{r}[s_i-s_{l-1}<k]\)，化简一下就成了\(\displaystyle\sum_{l}\displaystyle\sum_{r}[s_i<k+s_{l-1}]\)，直接倒着做然后树状数组查就行。别忘了离散化的时候要把\(S_0 = 0\)也离散进去（并没有想明白为什么）

#include <cstdio>
#include <algorithm>

const int N = 200000 + 10;
typedef long long LL;

LL a[N], s[N], b[N], c[N];
LL t;
int n, mx;
LL bt[N];

inline void add(int x) {
    for (; x <= mx; x += x&-x) {
        bt[x]++;
    }
}

inline LL query(int x) {
    LL ans = 0;
    for (; x>0; x -= x&-x) {
        ans += bt[x];
    }
    return ans;
}

int main() {
    scanf("%d%I64d", &n, &t);
    for (int i = 1; i <= n; ++i) {
        scanf("%I64d", &a[i]);
        s[i] = s[i-1] + a[i];
        b[i+1] = s[i];
    }
    std::sort(b+1, b+n+2);
    mx = std::unique(b+1, b+n+2) - b - 1;
    for (int i = 1; i <= n; ++i) {
        c[i] = std::lower_bound(b+1, b+mx+1, s[i]) - b;
    }
    LL ans = 0;
    for (int i = n; i; --i) {
        add(c[i]);
        int tmp = std::lower_bound(b+1, b+mx+1, s[i-1]+t) - b - 1;
        ans += query(tmp);
    }
    printf("%I64d\n", ans);
    return 0;
}

提交次数：\(5\)（离散化没加\(0\)，和lower_bound上界写错）

E Vasya and Magic Matrix

这个题还是能轻松的想到排序后从小到大枚举计算的。只是我一开始没有看到欧式距离的平方，苦思无解，只好去看题解，结果……

有平方的话就有交换律和结合律了，某个点的期望值为\(f_x = \displaystyle\frac{\displaystyle\sum_{1\le i\le k}(f_i + (r_x-r_i)^2 + (c_x-c_i)^2)}{k}\)，其中\(k\)是所有比他小的点的数量。化简之后就能发现这个式子只与比他小的数的个数，横纵坐标的和，横纵坐标的平方和，以及期望和有关。开几个变量记录一下就行（我图方便开了数组）

#include <cstdio>
#include <algorithm>

typedef long long LL;
const int N = 1e3 + 10;
const int M = N*N;
const LL MOD = 998244353;

struct node {
    LL x, y, h;
    bool operator< (const node &x) const {
        return h < x.h;
    }
} p[M];
int n, m, tot;
LL pos, sf[M], sx[M], sy[M], sx2[M], sy2[M], sk[M];
LL dp[N][N];
int x, y;

inline LL pow_mod(LL x, LL p) {
    LL ans = 1;
    while (p) {
        if (p&1) ans = ans * x % MOD;
        x = x * x % MOD;
        p = p >> 1;
    }
    return ans;
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            tot++;
            scanf("%I64d", &p[tot].h);
            p[tot].h++;
            p[tot].x = i;
            p[tot].y = j;
        }
    }
    scanf("%d%d", &x, &y);
    std::sort(p+1, p+tot+1);
    for (int i = 1; i <= tot; ++i) {
        if (p[i].h != p[i-1].h) {
            pos++;
            sf[pos] += sf[pos-1];
            sx[pos] += sx[pos-1];
            sy[pos] += sy[pos-1];
            sx2[pos] += sx2[pos-1];
            sy2[pos] += sy2[pos-1];
            sk[pos] += sk[pos-1];
        }
        LL f = 0;
        f = (f + sf[pos-1]) % MOD;
        f = (f + sx2[pos-1]) % MOD;
        f = (f + sy2[pos-1]) % MOD;
        f = (f + p[i].x * p[i].x % MOD * sk[pos-1] % MOD) % MOD;
        f = (f + p[i].y * p[i].y % MOD * sk[pos-1] % MOD) % MOD;
        f = (f - 2 * p[i].x % MOD * sx[pos-1] % MOD + MOD) % MOD;
        f = (f - 2 * p[i].y % MOD * sy[pos-1] % MOD + MOD) % MOD;
        f = f * pow_mod(sk[pos-1], MOD-2) % MOD;
        dp[p[i].x][p[i].y] = f;
        sf[pos] = (sf[pos] + f) % MOD;
        sx[pos] = (sx[pos] + p[i].x) % MOD;
        sy[pos] = (sy[pos] + p[i].y) % MOD;
        sx2[pos] = (sx2[pos] + p[i].x * p[i].x % MOD) % MOD;
        sy2[pos] = (sy2[pos] + p[i].y * p[i].y % MOD) % MOD;
        sk[pos] = (sk[pos] + 1) % MOD;
        if (p[i].x == x && p[i].y == y) break;
    }
    printf("%I64d\n", dp[x][y]);
    return 0;
}

提交次数：\(0+1\)

F Leaf Sets

这个题看了一会儿觉得不可做，就直接看了题解。

其实用了树形DP的思想，先dfs下去，再统计儿子们的答案然后上传。不过这个在dfs里开vector的操作惊到我了，我以前从未见过这样的写法（但是这样不会爆栈吗？）。

首先，对于一个叶子节点的集合，我们用这个集合中深度最大的点代表这个集合，因为只有这个点决定了两个集合能否合并。如果两个集合\(A,B\)的代表点\(d_A,d_B\)之间的距离小于\(k\)，那就可以合并，且合并后代表点的深度为\(max\{ d_A, d_B \}\)，如果大于\(k\)呢？不妨设\(d_A\le d_B\)，此时\(d_B\)一定没有用了，因为之后能和\(B\)合并的也一定能和\(A\)合并，那么\(B\)集合就不用再合并了，直接记录答案就行。

#include <cstdio>
#include <algorithm>
#include <vector>

const int N = 1e6 + 10;
const int M = 2e6 + 10;

int n, k;
int hd[N], to[M], nxt[M], cnt;
int dep[N], deg[N];
int ans;

inline void adde(int x, int y) {
    cnt++;
    to[cnt] = y;
    nxt[cnt] = hd[x];
    hd[x] = cnt;
}

int dfs(int x, int f) {
    if (deg[x] == 1) {
        return 0; // 叶子直接返回0
    }
    std::vector<int> d;
    for (int i = hd[x]; i; i = nxt[i]) if (to[i] != f) {
        d.push_back(dfs(to[i], x) + 1);
    }
    std::sort(d.begin(), d.end());
    while (d.size() >= 2) {
        if (d[d.size()-1] + d[d.size()-2] <= k) break;
        d.pop_back(); // 不能合并的就不合并了。
        ans++;
    }
    return d.back(); // 相当于把d中的所有集合合并了。
}

int main() {
    scanf("%d%d", &n, &k);
    for (int i = 1, x, y; i < n; ++i) {
        scanf("%d%d", &x, &y);
        adde(x, y);
        adde(y, x);
        deg[y]++; deg[x]++;
    }
    for (int i = 1; i <= n; ++i) if (deg[i] > 1) {
        dfs(i, 0);
        break;
    }
    printf("%d\n", ans+1); // 最后会剩下一个集合
    return 0;
}

提交次数：\(0+2\)（没有处理好叶子节点）