2024初秋集训——提高组 #32

B. 序列删除

题目描述

有一个长度为 $2N$ 的序列 $A$，其中 $1$ 到 $N$ 恰好出现两次。你每次可以选择两个相同的数 $A_l,A_r(l<r)$ 并花费 $r-l$ 的代价将其删除。求将整个序列删空的最小代价。

思路

有一个很显然的贪心就是：每次取代价最小的两个数删除。所以我们按照代价排序，用树状数组维护区间中未被删除的数的数量即可。

空间复杂度 $O(N)$，时间复杂度 $O(N\log N)$。

代码

#include<bits/stdc++.h>
using namespace std;
using ll = long long;

const int MAXN = 200001, MAXV = (1 << 20);

struct Node {
  int l, r;
}s[MAXN];

int n, a[MAXN], l[MAXN], tr[MAXN];
ll ans;

void update(int p, int x) {
  for(; p <= 2 * n; tr[p] += x, p += (p & -p)) {
  }
}

int Getsum(int p) {
  int sum = 0;
  for(; p; sum += tr[p], p -= (p & -p)) {
  }
  return sum;
}

int main() {
  ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  cin >> n;
  for(int i = 1; i <= 2 * n; ++i) {
    cin >> a[i];
    if(!l[a[i]]) {
      l[a[i]] = i;
    }else {
      s[a[i]] = {l[a[i]], i};
    }
  }
  sort(s + 1, s + n + 1, [](const Node &a, const Node &b) -> bool {
    return a.r - a.l < b.r - b.l;
  });
  for(int i = 1; i <= n; ++i) {
    ans += s[i].r - s[i].l - Getsum(s[i].r) + Getsum(s[i].l);
    update(s[i].l, 1), update(s[i].r, 1);
  }
  cout << ans;
  return 0;
}

C. 史莱姆融合

题目描述

在一棵 $N$ 个结点的树上，有 $k$ 只史莱姆，一开始在结点 $i{d}_i$，体积为 $v_i$。它们会如下行动：

• 如果一只史莱姆通过了边权为 $w$ 的边，则其体积减 $w$。若其体积变为非正数，则其消失。
• 如果多只史莱姆待在同一个结点，则它们将会合并为体积为其体积之和的史莱姆。
• 史莱姆最终都要到达一个结点 $c$，但它们会按最优方案行动。

有 $q$ 次查询，每次查询如果史莱姆要到达 $c$，且你一开始可以让 $num(num\in \{0,1\})$ 个史莱姆消失时最终史莱姆的最小体积。

思路

我们先只考虑 $c=1$ 的情况，那么我们可以令 $d{p}_{0/1,u}$ 表示在 $u$ 子树内删除了 $0/1$ 个史莱姆，最终子树内的史莱姆到达 $u$ 的体积。对于 $d{p}_{0,u}$，显然有转移 $d{p}_{0,u}=\sum _{(v,w)\in so{n}_u}max(0,d{p}_{0,v}-w)$。而对于 $d{p}_{1,u}$，我们可以选择删掉这个结点本身的，也可以选择一个儿子子树删，也就是 $d{p}_{1,u}=min(max(0,d{p}_{0,u}-w),\underset{v_0\in so{n}_u}{min}\{max(0,d{p}_{1,v_0})+\sum _{v\in so{n}_u\text{and}v\ne v_0}max(0,d{p}_{0,v})\})$。

接着我们考虑换根，$d{p}_{0,u}$ 的换根很简单，但 $d{p}_{1,u}$ 比较麻烦。如果 $v$ 不是 $d{p}_{1,u}$ 转移时最小的那个 $v_0$，那么可以直接转移。否则必须从次小值转移过来，所以这里还需要记录次小值。

空间复杂度 $O(N)$，时间复杂度 $O(N+K+Q)$。

代码

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;

const int MAXN = 100001;
const ll INF = (ll)(1e18);

int n, k, q, a[MAXN], son[MAXN];
ll dp[3][MAXN];
vector<pii> e[MAXN];

void dfs(int u, int fa) {
  dp[0][u] = a[u];
  for(pii g : e[u]) {
    int v = g.first, w = g.second;
    if(v != fa) {
      dfs(v, u);
      dp[0][u] += max(0ll, dp[0][v] - w);
    }
  }
  dp[1][u] = dp[0][u] - a[u], dp[2][u] = INF, son[u] = u;
  for(pii g : e[u]) {
    int v = g.first, w = g.second;
    if(v != fa) {
      ll x = dp[0][u] - max(0ll, dp[0][v] - w) + max(0ll, dp[1][v] - w);
      if(x < dp[1][u]) {
        dp[2][u] = dp[1][u], dp[1][u] = x, son[u] = v;
      }else if(x < dp[2][u]) {
        dp[2][u] = x;
      }
    }
  }
}

void DFS(int u, int fa) {
  for(pii g : e[u]) {
    int v = g.first, w = g.second;
    if(v != fa) {
      ll v0 = dp[0][v], u0 = dp[0][u] - max(0ll, v0 - w);
      dp[0][v] += max(0ll, u0 - w);
      dp[1][v] += max(0ll, u0 - w);
      dp[2][v] += max(0ll, u0 - w);
      if(son[u] != v) {
        ll x = dp[0][v] - max(0ll, u0 - w) + max(0ll, dp[1][u] - max(0ll, v0 - w) - w);
        if(x < dp[1][v]) {
          dp[2][v] = dp[1][v], dp[1][v] = x, son[v] = u;
        }else if(x < dp[2][v]) {
          dp[2][v] = x;
        }
      }else {
        ll x = dp[0][v] - max(0ll, u0 - w) + max(0ll, dp[2][u] - max(0ll, v0 - w) - w);
        if(x < dp[1][v]) {
          dp[2][v] = dp[1][v], dp[1][v] = x, son[v] = u;
        }else if(x < dp[2][v]) {
          dp[2][v] = x;
        }
      }
      DFS(v, u);
    }
  }
}

int main() {
  ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  cin >> n >> k >> q;
  for(int i = 1, u, v, w; i < n; ++i) {
    cin >> u >> v >> w;
    e[u].emplace_back(v, w);
    e[v].emplace_back(u, w);
  }
  for(int i = 1, u; i <= k; ++i) {
    cin >> u >> a[u];
  }
  dfs(1, 0);
  DFS(1, 0);
  for(int i = 1, u, v; i <= q; ++i) {
    cin >> u >> v;
    cout << dp[v][u] << "\n";
  }
  return 0;
}