AtCoder Beginner Contest 378

省流版

• A. 判断奇偶性即可
• B. 根据余数计算偏移天数即可
• C. 用map记录每个数出现的位置即可
• D. 枚举起点，枚举每步的方向，朴素搜索即可
• E. 考虑前缀和的两数相减代替区间和的情况，减为负数则加回正数，用树状数组维护减为负数的情况数
• F. 枚举点，作为连边的俩个点的lca，考虑维护路径点度数为$33..32$的数量，组合即可

A - Pairing (abc378 A)

题目大意

给定$4$个数。

问做的操作数，每次选两个相同的数，然后丢弃。

解题思路

统计每个数的出现次数$cnt_i$，答案就是 $\sum \lfloor \frac{cnt_i}{2} \rfloor$

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n = 4;
    array<int, 4> cnt{};
    while (n--) {
        int a;
        cin >> a;
        cnt[a - 1]++;
    }
    int ans = 0;
    for (auto& i : cnt) {
        ans += i / 2;
    }
    cout << ans << '\n';
 
    return 0;
}
 

---

B - Garbage Collection (abc378 B)

题目大意

$n$种垃圾，第 $i$种垃圾会在天数 $d$收取，其中 $d$满足 $d \% p_i = r_i$。

回答 $q$个询问，每个询问问在第 $d_i$天丢的第$t_i$种垃圾，会在第几天被收取。如果当天丢且当天可收取，则会被收取。

解题思路

假设$j = t_i$，先算$r = d_i \% p_j$，如果 $r \leq r_j$，那么很显然多过$r_j - r$天就会被收取。否则要过一个循环，即$p_j - r + r_j$天才会被收取。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    vector<array<int, 2>> a(n);
    for (auto& x : a)
        cin >> x[0] >> x[1];
    int Q;
    cin >> Q;
    while (Q--) {
        int t, d;
        cin >> t >> d;
        --t;
        auto [q, r] = a[t];
        int ans = (r - d % q + q) % q;
        cout << d + ans << '\n';
    }
 
    return 0;
}
 

---

C - Repeating (abc378 C)

题目大意

给定一个数组$a$，构造相同长度的数组 $b$，满足 $b_i$是 $a_i$上一次出现的位置，或者 $-1$。

解题思路

直接用map记录每个元素$a_i$上次出现的位置，然后输出$map[a_i]$即可

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    map<int, int> pos;
    for (int i = 0; i < n; i++) {
        int x;
        cin >> x;
        int ans = pos.count(x) ? pos[x] + 1 : -1;
        cout << ans << " \n"[i == n - 1];
        pos[x] = i;
    }
 
    return 0;
}
 

---

D - Count Simple Paths (abc378 D)

题目大意

给定一张二维平面，有障碍物。

问方案数，从任意点出发，上下左右走，可以走$k$步，不经过障碍物，且每个点只访问一次。

解题思路

由于平面$10 \times 10$， $k \leq 11$，直接花$O(hw)$枚举点，然后花$(4^k)$遍历所有方案。 其时间复杂度为$O(hw4^k)$，约为 $1e8$，可过。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int h, w, k;
    cin >> h >> w >> k;
    vector<string> s(h);
    for (auto& x : s)
        cin >> x;
    int ans = 0;
    array<int, 4> dx = {0, 1, 0, -1};
    array<int, 4> dy = {1, 0, -1, 0};
    auto ok = [&](int x, int y) -> bool {
        return 0 <= x && x < h && 0 <= y && y < w && s[x][y] != '#';
    };
    vector<vector<int>> visit(h, vector<int>(w, 0));
    auto dfs = [&](auto dfs, int x, int y, int cnt) -> void {
        if (cnt == k) {
            ++ans;
            return;
        }
        visit[x][y] = 1;
        for (int i = 0; i < 4; ++i) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            if (ok(nx, ny) && !visit[nx][ny]) {
                dfs(dfs, nx, ny, cnt + 1);
            }
        }
        visit[x][y] = 0;
    };
    for (int i = 0; i < h; ++i) {
        for (int j = 0; j < w; ++j) {
            if (s[i][j] == '#')
                continue;
            dfs(dfs, i, j, 0);
        }
    }
    cout << ans << '\n';
 
    return 0;
}
 

---

E - Mod Sigma Problem (abc378 E)

题目大意

给定数组$a$，和模数 $m$。求 $\sum_{1 \leq l \leq r \leq n} ((\sum_{l \leq i \leq r} a_i )\% m)$

解题思路

预处理前缀和$sum[i] = (\sum_{j \leq i} a_i )\% m$，则区间和 $[l,r]$可表示为 $sum[r] - sum[l - 1]$。

我们枚举$r$，然后求所有的 $l \leq r$，其区间和的和时多少。

由于取模的缘故，其结果但可能为负数，此时要$+ m$，但有多少个$l$需要加呢？自然就是$sum[l - 1] > sum[r]$的那些 $l$。

由于 $sum[i] \leq m$只有$1e5$，可以开一个计数的桶 $tree[i]$表示数字 $i$出现的次数，那么上述的 $l$的数量就是 $\sum_{i > sum[r]} tree[i]$。假设其数量为$k$，那么当前 $r$对答案的贡献即为 $(\sum_{l \leq r} sum[r] - sum[l - 1]) + km = r \times sum[r] - \sum_{l \leq r} sum_[l - 1] + km$。中间一项就是前缀和的前缀，而 $k$就是$\sum_{i > sum[r]} tree[i]$。

关于$k$的求法，涉及到区间求和和单点修改，因此可以用权值树状数组或权值线段树维护这个桶即可。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
// starting from 0
template <typename T> class fenwick {
  public:
    vector<T> fenw;
    int n;
 
    fenwick(int _n) : n(_n) { fenw.resize(n); }
 
    void modify(int x, T v) {
        while (x < n) {
            fenw[x] += v;
            x |= (x + 1);
        }
    }
 
    T get(int x) {
        T v{};
        while (x >= 0) {
            v += fenw[x];
            x = (x & (x + 1)) - 1;
        }
        return v;
    }
};
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, m;
    cin >> n >> m;
    int presum = 0;
    LL ppresum = 0;
    fenwick<int> cnt(m);
    LL ans = 0;
    cnt.modify(0, 1);
    for (int i = 0; i < n; ++i) {
        int a;
        cin >> a;
        a %= m;
        presum = (presum + a) % m;
        int cc = i + 1 - cnt.get(presum);
        ans += 1ll * (i + 1) * presum - ppresum + 1ll * m * cc;
        cnt.modify(presum, 1);
        ppresum += presum;
    }
    cout << ans << '\n';
 
    return 0;
}
 

下述想的比较复杂度，同样是枚举$r$，然后看所有$[l,r-1] \to [l,r]$区间和的变化。分两类，一类是直接$[l,r-1] + a_r = [l, r]$ ，另一类是$[l,r-1] + a_r - m = [l,r]$ 。

因为区间和的范围同样在$[0,m-1]$，所以用权值线段树维护 $cnt_i$表示区间和$[l,r]=i$的数量，当新增 $a_r$时，线段树里的数据都是$[l..r-1]$的区间和个数，考虑计算贡献，即$cnt_{0..m - a_i}$属于第一类， $cnt_{m - a_i..m-1}$属于第二类。

分别计算贡献后，考虑$cnt_i$怎么变化，即怎么变成$[l..r]$的区间和个数。由于所有数增加了$a_r$，因此$cnt_i$会进行一个整体偏移 ，即$cnt_{i+a_r} = cnt_i$，但直接这么做是 $O(n)$的，不能这么做。但考虑到是整体偏移，我们可以记录此时表示 $cnt_0$的位置，即原来在$[l,r-1]$时，$cnt_0$ 表示区间和为$0$的个数，在增加 $a_r$后， $cnt_{m - a_r}$就表示区间和为 $0$的个数。即我们自定义$cnt_0$的位置，这样就是整体偏移了。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
const int N = 2e5 + 8;
 
class segment {
#define lson (root << 1)
#define rson (root << 1 | 1)
  public:
    LL cnt[N << 2];
    LL sum[N << 2];
    LL lazy[N << 2];
    int n;
 
    void pushup(int root) {
        cnt[root] = cnt[lson] + cnt[rson];
        sum[root] = sum[lson] + sum[rson];
    }
 
    void build(int root, int l, int r) {
        if (l == r) {
            cnt[root] = 0;
            sum[root] = 0;
            return;
        }
        int mid = (l + r) >> 1;
        build(lson, l, mid);
        build(rson, mid + 1, r);
        pushup(root);
    }
 
    void pushdown(int root, int l, int mid, int r) {
        if (lazy[root]) {
            sum[lson] += lazy[root] * cnt[lson];
            sum[rson] += lazy[root] * cnt[rson];
            lazy[lson] += lazy[root];
            lazy[rson] += lazy[root];
            lazy[root] = 0;
        }
    }
 
    void update(int root, int l, int r, int L, int R, LL val) {
        if (L > R)
            return;
        if (L <= l && r <= R) {
            sum[root] += val * cnt[root];
            lazy[root] += val;
            return;
        }
        int mid = (l + r) >> 1;
        pushdown(root, l, mid, r);
        if (L <= mid)
            update(lson, l, mid, L, R, val);
        if (R > mid)
            update(rson, mid + 1, r, L, R, val);
        pushup(root);
    }
 
    void insert(int root, int l, int r, int pos, LL val) {
        if (l == r) {
            cnt[root] += 1;
            sum[root] += val;
            return;
        }
        int mid = (l + r) >> 1;
        pushdown(root, l, mid, r);
        if (pos <= mid)
            insert(lson, l, mid, pos, val);
        else
            insert(rson, mid + 1, r, pos, val);
        pushup(root);
    }
 
    pair<int, LL> query(int root, int l, int r, int L, int R) {
        if (L <= l && r <= R) {
            return {cnt[root], sum[root]};
        }
        int mid = (l + r) >> 1;
        pushdown(root, l, mid, r);
        pair<int, LL> ans = {0, 0};
        if (L <= mid) {
            auto tmp = query(lson, l, mid, L, R);
            ans.first += tmp.first;
            ans.second += tmp.second;
        }
        if (R > mid) {
            auto tmp = query(rson, mid + 1, r, L, R);
            ans.first += tmp.first;
            ans.second += tmp.second;
        }
        return ans;
    }
 
    pair<int, LL> query_from(int root, int l, int r, int L, int R) {
        if (L > R)
            return {0, 0};
        L = (L % n + n) % n + 1;
        R = (R % n + n) % n + 1;
        debug(L, R);
        if (L <= R)
            return query(root, l, r, L, R);
        pair<int, LL> ans = {0, 0};
        auto tmp = query(root, l, r, L, r);
        ans.first += tmp.first;
        ans.second += tmp.second;
        tmp = query(root, l, r, 1, R);
        ans.first += tmp.first;
        ans.second += tmp.second;
        return ans;
    }
 
    void update_from(int root, int l, int r, int L, int R, LL val) {
        if (L > R)
            return;
        L = (L % n + n) % n + 1;
        R = (R % n + n) % n + 1;
        if (L <= R)
            update(root, l, r, L, R, val);
        else {
            update(root, l, r, L, r, val);
            update(root, l, r, 1, R, val);
        }
    }
 
} sg;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, m;
    cin >> n >> m;
    vector<int> a(n);
    for (auto& x : a) {
        cin >> x;
        x %= m;
    }
    sg.build(1, 1, m);
    sg.n = m;
    int l = 0;
    LL ans = 0;
    for (int i = 0; i < n; i++) {
        int r = l + m - a[i];
        auto [cnt, sum] = sg.query_from(1, 1, m, l, r - 1);
        ans += 1ll * cnt * a[i] + sum;
        auto [cnt2, sum2] = sg.query_from(1, 1, m, r, l + m - 1);
        ans += 1ll * cnt2 * (a[i] - m) + sum2;
 
        sg.update_from(1, 1, m, l, r - 1, a[i]);
        sg.update_from(1, 1, m, r, l + m - 1, a[i] - m);
        l = r % m;
        sg.insert(1, 1, m, (l + a[i]) % m + 1, a[i]);
        ans += a[i];
    }
    cout << ans << '\n';
 
    return 0;
}
 

---

F - Add One Edge 2 (abc378 F)

题目大意

给定一棵树，求加一条边的方案数，使得没有重边，且环上的所有点的度数为$3$。

解题思路

加一条边$u \to v$，首先这两个点的度数为 $2$，然后假设 $u \to v$路径上的所有点的度数为 $3$。

假设 $u,v$的最近公共祖先是 $lca$，即 $u \to lca$， $v \to lca$的所有点的度数为 $3$。

注意到这是一个向父亲方向的，要求路径上所有点为 $3$的信息，可以通过预处理 $up[i]$表示从 $i$往父亲走，其点度为 $3$的最浅深度之类的信息。然后我们只需枚举 $u,v$，看 $up[u],up[v]$与 $lca$的深度关系，即可知道加的这条边 $u \to v$是否符合要求。

但上述时间复杂度为 $O(n^2)$，我们考虑枚举 $lca$，然后看其子树有多少对符合条件的 $u,v$。

从 $lca$的角度，我们需要什么信息？即从该 $lca$往儿子方向走，其一路点度数为 $3$，最后一个点度数为 $2$，这样的路径条数。不同子树之间的这类点就可以连边（当然 $lca$的度数也要是 $3$）。

注意重边的情况，即 $lca$度数为 $2$，其一个儿子的度数也为 $2$。

上述过程可能就是树形$dp$（？$dp[i]$表示 $i$子树内，一路往儿子方向，其点度数为 $3$，最后一个点度数为 $2$的路径条数，然后合并不同子树时计算匹配的点对。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    vector<vector<int>> edge(n);
    vector<int> du(n);
    for (int i = 0; i < n - 1; i++) {
        int u, v;
        cin >> u >> v;
        u--;
        v--;
        edge[u].push_back(v);
        edge[v].push_back(u);
        du[u]++;
        du[v]++;
    }
    LL ans = 0;
    auto dfs = [&](auto dfs, int u, int fa) -> int {
        int ret = 0;
        for (int v : edge[u]) {
            if (v == fa)
                continue;
            int nxt = dfs(dfs, v, u);
            if (du[u] == 2)
                ans += nxt;
            else if (du[u] == 3)
                ans += 1ll * nxt * ret;
            ret += nxt;
        }
        if (du[u] == 2)
            return 1;
        else if (du[u] == 3)
            return ret;
        else
            return 0;
    };
    dfs(dfs, 0, 0);
    int extra = 0;
    for (int u = 0; u < n; u++) {
        for (auto v : edge[u]) {
            if (du[u] == 2 && du[v] == 2)
                extra++;
        }
    }
    ans -= extra / 2;
    cout << ans << '\n';
 
    return 0;
}
 

---

G - Everlasting LIDS (abc378 G)

题目大意

给定$a,b,m$，求 $1 \sim ab$的全排列数量，满足以下条件：

• 最长上升子序列长度为$a$
• 最长下降子序列长度为$b$
• 存在 $n$使得在末尾增加一个数 $n+0.5$，其上述两个长度不改变。

输出数量对 $m$取模。

解题思路

<++>

神奇的代码

---