[AtCoder] NIKKEI Programming Contest 2019

本来看见这一场的排名的画风比较正常就来补一下题，但是完全没有发现后两题的AC人数远少于我补的上一份AtCoder。

A - Subscribers

首先始终 \(max = \min(A, B)\) ，\(min\) 的话如果 \(A + B \leq N\) ，那么就是 \(0\) ，否则就是 \(A + B - N\) 。

int n, a, b;

int main() {
    read(n), read(a), read(b);
    if (a + b <= n) printf("%d 0\n", std::min(a, b));
    else printf("%d %d\n", std::min(a, b), a + b - n);
}

B - Touitsu

直接枚举每一位，看看有几个相同的就行了。

int n, ans;
char a[N], b[N], c[N];

int main() {
    scanf("%d%s%s%s", &n, a + 1, b + 1, c + 1);
    for (int i = 1; i <= n; ++i) {
        if(a[i] == b[i] && b[i] == c[i]) ;
        else if(a[i] != b[i] && a[i] != c[i] && b[i] != c[i]) ans += 2;
        else ++ans;
    }
    printf("%d\n", ans);
}

C - Different Strokes

挺好一道题，就是有点简单。

我们考虑对于每一个人来说，假设他选的集合是 \(S\) ，他要最大化这个东西：

\[ \sum_{i \in S} a[i] - \sum_{i \notin S} b[i] \]

如果我们假设 \(B = \sum \limits_{i = 1} ^ n b[i]\) ，那么上式可化为：

\[ (\sum_{i \in S} a[i] +b[i]) -B \]

因此不管是谁，都应该尽量选择 \(a[i]+b[i]\) 大的位置上的数。直接用一个堆维护一下就可了。（不过好像可以直接排一下序就可以啦，我似乎傻掉了）

const int N = 1e5 + 7;

int n, a[N], b[N];
ll ans;

struct cmp {
    int operator () (const int &x, const int &y) const {
        return a[x] + b[x] < a[y] +b[y]; 
    }
};
std::priority_queue<int, std::vector<int>, cmp> q;

int main() {
    read(n);
    for (int i = 1; i <= n; ++i) read(a[i]), read(b[i]), q.push(i);
    for (int i = 1; i <= n; ++i) if (i & 1) ans += a[q.top()], q.pop(); else ans -= b[q.top()], q.pop();
    printf("%lld\n", ans);
}

D - Restore the Tree

怎么感觉 D 比 C 还简单啊。至少 C 还要想一会儿列个式子，这道题好像是读完题就可以开始写了。

因为保证新加的边始终是从祖先连向孩子的，所以图里面的边实际上表示了深度的大小关系，因此根肯定还是入度为 0 的。找到根以后拓扑排序一下就可了，最后一个拓扑到 \(i\) 的点就是 \(i\) 的父亲。

const int N = 1e5 + 7;

int n, m, x, y, rt, idg[N], fa[N];

struct Edge {int to, ne;} g[N]; int head[N], tot;
inline void Addedge(int x, int y) {g[++tot].to = y; g[tot].ne = head[x]; head[x] = tot;}

int q[N], hd, tl;
inline void BFS() {
    q[++tl] = rt;
    while (hd < tl) {
        int x = q[++hd];
        for fec(i, x, y) if (!--idg[y]) fa[y] = x, q[++tl] = y;
    }
}

int main() {
    #ifdef hzhkk
    freopen("hkk.in", "r", stdin);
    #endif
    read(n), read(m);
    for (int i = 1; i <= n - 1 + m; ++i) read(x), read(y), Addedge(x, y), ++idg[y];
    for (int i = 1; i <= n; ++i) if(!idg[i]) rt = i;
    BFS();
    for (int i = 1; i <= n; ++i) printf("%d\n", fa[i]);
}

E - Weights on Vertices and Edges

好题啊。

一开始我想的是肯定要从大到小枚举边要不要删。然后可以发现不在最小生成树上的边不管怎么删都不影响原图的连通性，于是可以直接把原图变成一棵树的时候，那么可以直接上 LCT 来维护连通性以及一些信息。但是似乎方法是成立的，只是额在AtCoder上如果还要写LCT，是真的不敢想啊。

于是又思考了一个小时，也没什么新思路，只能去看了一下题解。

是这样的，我们对于删边发过来，变成从小到大加边，用并查集来维护一下每个联通块的点权和。但是我们会发现，有些边可能之前是不能加的，但是随着后续的加边，联通块扩大了，那些边就可以加入了！

题解提供了一种很巧妙的办法，我们对于那样的边，我们把它们的联通块先连起来，但是并查集要记录所有并没有真正加进去的边的数量，显然后面如果我们真正加边的时候，就可以把该联通块并完以后，里面没有加的边都加进去了。

const int N = 1e5 + 7;

int n, m, w[N], ans;
struct Edge{int x, y, z;} g[N];

int fa[N], num[N];
ll sum[N];
inline int Find(int x) {return fa[x] == x ? x : fa[x] = Find(fa[x]);}
inline void Union(int x, int y) {
    fa[y = Find(y)] = x = Find(x);
    num[x] += num[y], num[y] = 0;
    sum[x] += sum[y], sum[y] = 0;
}

int main() {
    #ifdef hzhkk
    freopen("hkk.in", "r", stdin);
    #endif
    read(n), read(m);
    for (int i = 1; i <= n; ++i) read(w[i]), fa[i] = i, sum[i] = w[i];
    for (int i = 1; i <= m; ++i) read(g[i].x), read(g[i].y), read(g[i].z);
    std::sort(g + 1, g + m +1, [](const Edge &a, const Edge &b){return a.z < b.z;});
    for (int i = 1; i <= m; ++i) {
        int x = Find(g[i].x), y = Find(g[i].y), z = g[i].z;
        if (Find(x) != Find(y)) Union(x, y);
        ++num[x];
        if (sum[x] >= z) ans += num[x], num[x] = 0;
    }
    printf("%d\n", m - ans);
}

后来到网上又翻了一会儿题解，发现我之前的方法还是有救的，而且还有两种解救的办法。

第一种是通过不带路径压缩，只用按秩合并来做的并查集，这种并查集的单次操作的时间复杂度是 \(O(\log n)\) 的，而且因为没有路径压缩，可以很方便地实现 Cut 操作，比 LCT 好写，当然也就只适合这道题了，并查集扩展性没有 LCT 好。

第二种是建立 Kruskal 重构树。那么在从小到大枚举最小生成树里面的边的时候，对于一条边，如果其父亲没有被删除，那么显然他自己也不需要被删除了。因此如果判断的话，首先判断其父亲有没有被删，然后再看看其所在联通块的点权和——其现在所在联通块就是在重构树上的子树！这样的方法，因为删边时一定是从根山道这条边的，所以不需要更该其祖先的子树和的信息。

此上三中方法的时间复杂度都是 \(O(m\log n)\) 。我就只写了第一种。

F - Jewels

想了两个小时也不会做，上网找题解也找不到，看来我可能需要去研读一下官方的英文题解。但是由于我英语比较烂，所以F可能要咕。