ABC479

C. Bento Packing

二进制枚举

代码实现

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)

using namespace std;
using ll = long long;

int main() {
    int n, w;
    cin >> n >> w;
    
    vector<int> a(n), b(n);
    rep(i, n) cin >> a[i] >> b[i];
    
    ll ans = 0;
    rep(s, 1<<n) {
        ll sa = 0, sb = 0;
        rep(i, n) if (s>>i&1) {
            sa += a[i];
            sb += b[i];
        }
        if (sb <= w) ans = max(ans, sa);
    }
    
    cout << ans << '\n';
    
    return 0;
}

D. Back and Forth Distance

在位置 \(i\) 向左任意跳代价是 \(L_i\)，向右任意跳代价是 \(R_i\) 。连续同向的多次跳可以合并为一次，所以最优路径至多需要两次跳：要么一次直接跳到目标，要么先跳到反方向某处再跳回目标方向（两次）。
只需预处理一下后缀最小的 \(L_i\) 数组以及前缀最小的 \(R_i\) 数组，就能做到 \(\mathcal{O}(1)\) 询问了。

代码实现

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)

using namespace std;

int main() {
    int n, q;
    cin >> n >> q;
    
    vector<int> l(n), r(n);
    for (int i = 1; i < n; ++i) cin >> l[i];
    rep(i, n-1) cin >> r[i];
    
    vector<int> cl = l, cr = r;
    for (int i = n-2; i >= 0; --i) cl[i] = min(cl[i], cl[i+1]);
    for (int i = 1; i < n; ++i) cr[i] = min(cr[i], cr[i-1]);
    
    rep(qi, q) {
        int s, t;
        cin >> s >> t;
        --s; --t;
        int ans;
        if (t < s) {
            ans = min(l[s], r[s]+cl[s]);
        }
        else {
            ans = min(r[s], l[s]+cr[s]);
        }
        cout << ans << '\n';
    }
    
    return 0;
}

E. Cut and Add

树上差分

假设第 \(i\) 条边为 \((a, b)\)，且 \(a\) 是 \(b\) 的父节点
断开第 \(i\) 条边

• 如果以 \(b\) 为根的子树更大，就直接在点 \(b\) 上打一个 \(\mathbin{+}i\) 的标记
• 否则，在点 \(1\) 上打一个 \(\mathbin{+}i\) 的标记，同时在点 \(b\) 上打一个 \(\mathbin{-}i\) 的标记

然后从点 \(1\) 开始跑一遍 \(\text{dfs}\) 把差分标记下放

代码实现

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)

using namespace std;
using ll = long long;
using P = pair<int, int>;

int main() {
    int n;
    cin >> n;
    
    vector<vector<int>> to(n);
    vector<P> es;
    rep(i, n-1) {
        int a, b;
        cin >> a >> b;
        --a; --b;
        to[a].push_back(b);
        to[b].push_back(a);
        es.emplace_back(a, b);
    }
    
    vector<int> t(n);
    {
        auto dfs = [&](this auto dfs, int v, int p=-1) -> int {
            t[v] = 1;
            for (int u : to[v]) {
                if (u == p) continue;
                t[v] += dfs(u, v);
            }
            return t[v];
        };
        dfs(0);
    }
    
    vector<ll> d(n);
    rep(i, n-1) {
        auto [a, b] = es[i];
        if (t[a] < t[b]) swap(a, b);
        if (t[b] > n-t[b]) {
            d[b] += i+1;
        }
        else {
            d[0] += i+1;
            d[b] -= i+1;
        }
    }
    
    {
        auto dfs = [&](this auto dfs, int v, int p=-1) -> void {
            for (int u : to[v]) {
                if (u == p) continue;
                d[u] += d[v];
                dfs(u, v);
            }
        };
        dfs(0);
    }
    
    rep(i, n) cout << d[i] << " \n"[i == n-1];
    
    return 0;
}

F. Narrow Passage

把人在数轴上从左到右的初始顺序固定下来（按 \(S_i\) 升序排序），第 \(i\) 个就是当前从左数第 \(i\) 个人。操作本质上要么把某人向邻位交换（当目标格被占时发生交换），要么把某人移动到空格（不改变相对顺序）。

因此将所有人移动到各自目标位置可以拆成两部分：

• 调整相对顺序，使得人的相对次序与目标位置的相对次序一致。这部分的最小操作数等于按初始顺序列出的目标位置秩序的逆序数（每一次相邻交换就是一次逆序消除）。
• 在相对顺序固定后，把每个人移动到确切的目标坐标。这相当于在“去掉序号偏移”的一维上把每个人从位置 \(S_i - i\) 移到 \(T_i - rank(i)\)（\(rank(i)\) 为该人目标坐标在所有目标坐标中的排名）。每一步操作只能改变某人坐标 \(\mathbin{±}1\)（且不改变相对顺序），因此这部分的最小操作数为这些差值绝对值之和：\(\sum |(S_i - i) - (T_i - rank(i))|\)。

代码实现

#include <bits/stdc++.h>
#include <atcoder/all>
using namespace atcoder;
#define rep(i, n) for (int i = 0; i < (n); ++i)

using namespace std;
using ll = long long;
using P = pair<int, int>;

// Coodinate Compression
template<typename T=int>
struct CC {
  bool initialized;
  vector<T> xs;
  CC(): initialized(false) {}
  void add(T x) { xs.push_back(x);}
  void init() {
    sort(xs.begin(), xs.end());
    xs.erase(unique(xs.begin(),xs.end()),xs.end());
    initialized = true;
  }
  int operator()(T x) {
    if (!initialized) init();
    return upper_bound(xs.begin(), xs.end(), x) - xs.begin() - 1;
  }
  T operator[](int i) {
    if (!initialized) init();
    return xs[i];
  }
  int size() {
    if (!initialized) init();
    return xs.size();
  }
};

int main() {
    int n;
    cin >> n;
    
    vector<P> a(n);
    rep(i, n) cin >> a[i].first;
    rep(i, n) cin >> a[i].second;
    ranges::sort(a);
    
    ll ans = 0;
    vector<int> b(n);
    {
        CC cc;
        rep(i, n) cc.add(a[i].second);
        rep(i, n) b[i] = cc(a[i].second);
    }
    
    {
        fenwick_tree<int> t(n);
        rep(i, n) {
            ans += i - t.sum(0, b[i]);
            t.add(b[i], 1);
        }
    }
    
    rep(i, n) {
        int s = a[i].first - i;
        int t = a[i].second - b[i];
        ans += abs(s-t);
    }
    
    cout << ans << '\n';
    
    return 0;
}

G. Tuning

条件是所有点都在同一条直线上。当固定一条直线时，通过水平移动还是垂直移动到达直线才是最优的，这一选择仅由直线的斜率决定，且对所有点都一致。我们需要分别尝试垂直移动和水平移动这两种情况。对于垂直移动，设直线为 \(y = mx\)，若将 \(m\) 视为变量来考虑代价函数，则每个点 \((A_i, B_i)\) 的贡献为 \(\vert{}A_i\vert{} \vert{}m - A_i/B_i\vert{}\)，而最优的 \(m\) 应该位于使 \(\vert{}A_i\vert{}\) 的权重之和达到良好平衡的位置。