【解题总结】NWERC 2019（Codeforces Gym 102500）

我解决的：E（1 WA）、F、I、A。

没看的：H。

旁观的：C、G、D。

看了但没做出来的：K、B、J。

E Expeditious Cubing

简单题，略。

C Canvas Line

看起来是一个不很难的贪心，略。

F Firetrucks Are Red

题意：有 $n$ 个点，每个点有一个数集。两个点的数集有非空交集则两个点可以以该数为权，连一条边。求一个生成树。

枚举数，将具有相同数的点连起来即可，要用并查集维护连通性。

#include 
using namespace std;
unordered_map<int, int> mp;
int tot, lst[200005];
int to[200005], nxt[200005], at[200005] = {0}, cnt = 0;
int ans[200005][3];
int fa[200005], siz[200005];
int Find(int x){
    return (x == fa[x] ? x: (fa[x] = Find(fa[x])));
}
int Union(int u, int v){
    u = Find(u), v = Find(v);
    if (u == v) return 0;
    if (siz[u] > siz[v]) fa[v] = u, siz[u] += siz[v];
    else fa[u] = v, siz[v] += siz[u];
    return 1;
}
int main(){
    int n;
    scanf("%d", &n);
    tot = 0;
    for (int i = 1; i <= n; ++i){
        int t, num;
        scanf("%d", &t);
        for (int j = 1; j <= t; ++j){
            scanf("%d", &num);
            if (!mp.count(num)) {
                mp[num] = ++tot;
                lst[tot] = num;
            }
            int id = mp[num];
            to[++cnt] = i, nxt[cnt] = at[id], at[id] = cnt;
        }
    }
    for (int i = 1; i <= n; ++i)
        fa[i] = i, siz[i] = 1;
    
    int res = 0;
    for (int i = 1; i <= tot; ++i){
        if (!at[i]) continue;
        int rep = to[at[i]];
        for (int j = at[i]; j; j = nxt[j]){
            if (Union(to[j], rep)){
                ans[++res][0] = to[j], 
                ans[res][1] = rep, 
                ans[res][2] = lst[i];
            }
        }
    }
    if (res < n - 1) {
        printf("impossible\n");
    }else {
        for (int i = 1; i <= res; ++i){
            printf("%d %d %d\n", ans[i][0], ans[i][1], ans[i][2]);
        }
    }
    return 0;
}

I Inverted Deck

题意：给定一个序列，问能否反转一个连续子序列使得序列不降。

先把相同的数缩成一个，使得序列中没有相邻的相同数。设序列为 $a$，从头开始，第一个不满足 $a_i\le a_{i+1}$ 的 $i$ 为 $t$。可以看出，翻转的左端必须为 $a_t$，前了或者后了都不行。

然后找到 $a_t$ 后面 $a$ 的最小值，设为 $a_p$。那么只能翻转 $[t,p]$ 这一区间。如果成功就有解，否则就无解。

时间复杂度为 $O(n)$。

#include 
using namespace std;
int n;
int a[1000005], b[1000005], tmp[1000005];
int st[1000005][2];
int main(){
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i)
        scanf("%d", &a[i]);
    int nn = 0;
    for (int i = 1, j; i <= n; i = j){
        j = i;
        while (j <= n && a[i] == a[j])
            ++j;
        b[++nn] = a[i];
        st[nn][0] = i, st[nn][1] = j - 1;
    }

    int t = 1;
    while (t < nn && b[t + 1] >= b[t])
        ++t;
    if (t == nn){
        // no need
        printf("1 1\n");
        return 0;
    }

    int mini = 2000000000, p = t;
    for (int i = t; i <= nn; ++i){
        if (b[i] <= mini) mini = b[i], p = i;
    }

    // [t, p]
    for (int i = 1; i <= t - 1; ++i)
        tmp[i] = b[i];
    for (int i = p + 1; i <= nn; ++i)
        tmp[i] = b[i];
    for (int i = t, j = p; i <= p; ++i, --j)
        tmp[i] = b[j];

    bool flag = true;
    for (int i = 1; i < nn; ++i){
        if (tmp[i] > tmp[i + 1]){
            flag = false;
            break;
        }
    }

    if (!flag){
        printf("impossible\n");
    }else {
        printf("%d %d\n", st[t][0], st[p][1]);
    }
    return 0;
}

A Average Rank

题意：有 $n$ 个人，$w$ 场比赛。每场比赛会有一些人拿 1 分。每场比赛结束有排名，对于某个人，如果有 $x$ 个人分数比他高，那么他的名次就是 $x+1$。问 $w$ 场比赛结束后，每个人的场均排名，即每一场的排名之和除以 $w$。

显然，我们的目标是先求出每个人的每场排名的和。

我们先考虑如何维护排名。为了维护排名，我们可以对每一个分数维护一个 tag。一个人的排名就是其所在分数的 tag。如果一个人加了 1 分，若设其原始分数为 $t$，则只需要让 tag[t] 加 1 即可。

会发现这样定义的排名比原始定义总是少 1，不过这并不重要。

如此，更新排名只要 $O(1)$ 的时间，我们就可以在每一场结束后，对每一个人加上自己分数的 tag 以更新答案。总时间复杂度为 $O(nw)$。

但这样时间复杂度太高了。我们考虑对每一个分数再维护一个 tot_tag，表示从比赛开始到某一时刻为止，所有 tag 的累积。那么我们只要在所有比赛结束后，对每一个人加上自己分数的 tot_tag 就可以得到答案了。

现在问题在于怎么维护 tot_tag。我们仿照 lazy tag 的做法，只有要用到 tot_tag 时才更新。那么需要对每一个分数记录其最后更新的时间。例如在第 $i$ 场用到了分数 $j$，那么就可以先结算到前 $i-1$ 场为止的 tot_tag。

不结算到第 $i$ 场是因为可能第 $i$ 场信息未更新完。

为了消除人的分数提高 1 分的影响，设提高前分数为 $t$，那么要先加上 tot_tag[t] 再减去 tot_tag[t+1]。

最后的时间复杂度就是线性的。

#include 
using namespace std;
typedef long long ll;
int n, w;
int lst[1000005] = {0}, tag[1000005] = {0};
ll ans[300005] = {0}, tot_tag[1000005] = {0};
int pos[300005]; 
int st[1000005], top;
bool vis[1000005] = {0};
void update(int cur, int curtime){
    if (!vis[cur]){
        vis[cur] = true, st[++top] = cur;
        tot_tag[cur] += 1ll * (curtime - 1 - lst[cur]) * tag[cur];
        lst[cur] = curtime - 1;
    }
}
int main(){
    scanf("%d%d", &n, &w);

    for (int i = 1; i <= w; ++i){
        int k, id;
        scanf("%d", &k);
        top = 0;
        for (int j = 1; j <= k; ++j){
            scanf("%d", &id);
            int cur = pos[id];
            
            update(cur, i);
            update(cur + 1, i);
            ans[id] += tot_tag[cur];
            ans[id] -= tot_tag[cur + 1];
            
            ++tag[cur];
            ++pos[id];
        }

        for (int j = 1; j <= top; ++j){
            vis[st[j]] = false;
        }
    }

    for (int i = 1; i <= n; ++i){
        acctag[pos[i]] += 1ll * (w - lst[pos[i]]) * tag[pos[i]];
        lst[pos[i]] = w;

        ans[i] += acctag[pos[i]];
        double ave = (double)ans[i] / (double)w;
        ave += 1.0;
        // rank: base-0
        printf("%.20lf\n", ave);
    }

    return 0;
}

G Gnoll Hypothesis

题意：怪物池中有 $n$ 只怪物，每只怪物的生成概率为 $p_i$。每次随机选中其中 $k$ 只，不生成的怪物原本的生成概率将会向后转移给下一只会可能生成的怪物（如果最后的怪物不会生成，那么概率会转移给第一只可能生成的）。求每个怪物生成概率的期望。

对每一个位置的怪物，利用期望的线性性质，计算其前面每一个怪物对其期望的贡献即可。如对于怪物 $i$，那么位置为 $i-d$ 的怪物的贡献就是
$$p_{i-d}\cdot \frac{\left(\genfrac{}{}{0ex}{}{n-d-1}{k-1}\right)}{\left(\genfrac{}{}{0ex}{}{n}{k}\right)}$$

朴素的做是 $O(n^2)$ 的。由于算贡献本身是一个卷积，因此也可以用 FFT 做。

H Height Profile

题意：给定 $n+1$ 个点 $(i,h_i),0\le i\le n$，$i$ 号点和 $i+1$ 号点之间以直线段连接。$k$ 次询问，每次给出一个斜率 $g$，问是否有线段上的两个点满足连线斜率至少为 $g$，如果有，还要求出可行的两个点之间水平距离的最大值。

由于 $k$ 很小，考虑每次分别回答询问。

可以发现，每次回答中，至少有一个点的横坐标是整数，否则可以上下移动线段，不改变斜率而增加水平距离。于是枚举左端点或者右端点，希望在另一头更新答案。

以枚举右端点为例，由于相邻点间线段连续，如果当前枚举到横坐标 $j$，那么只要有 $i<j$ 符合 $\frac{h_j-h_i}{j-i}\ge g$ 就有解。我们找到满足此条件的最小的 $i$，然后另一个端点就出在 $i$ 左侧的线段上。枚举左端点同理。

对 $h_i-ig$ 排序，然后按该值从小到大枚举 $i$ 求解。这样解决的时间复杂度为 $O(kn\log n)$。

#include 
using namespace std;
int n, k, h[100005], hh[100005];
pair<int, int> p[100005];
char g[1005];
void init(){
    scanf("%d%d", &n, &k);
    for (int i = 0; i <= n; ++i)
        scanf("%d", &h[i]);
}
void solve(){
    while (k--){
        scanf("%s", g);
        int l = strlen(g);
        g[l - 2] = g[l - 1], g[--l] = '\0';
        int gg = atoi(g);
        
        for (int i = 0; i <= n; ++i){
            p[i].first = hh[i] = h[i] - i * gg, 
            p[i].second = i;
        }
        sort(p, p + n + 1);

        // 从小到大枚举值
        int mini = p[0].second;
        double ans = -1;
        for (int i = 1; i <= n; ++i){
        	// 此处，左右端点可以同时枚举
            int cur = p[i].second;
            if (mini > cur) {
                mini = cur;
                continue;
            }
            double offset = 0;
            // mini 作为左端点
            if (mini > 0){
                offset = max(offset, (double)(hh[cur] - hh[mini]) / 
                    fabs(hh[mini] - hh[mini - 1]));
            }
            // 当前端点作为右端点
            if (p[i].second < n){
                offset = max(offset, (double)(hh[cur] - hh[mini]) / 
                    fabs(hh[cur + 1] - hh[cur]));
            }
            ans = max(ans, cur - mini + min(1.0, offset));
        }

        if (ans < 0) printf("-1\n");
        else printf("%.20lf\n", ans);
    }
}
int main(){
    init();
    solve();
    return 0;
}

D Disposable Switches

待补。。。

J Jackdaws and Crows

待补。。。

K Kitesurfing

待补。。。

B Balanced Cut

待补。。。