Codeforces Round 595 (Div. 3)
Codeforces Round 595 (Div. 3)
D2. Too Many Segments (hard version)
题意：
给你 \(n\) 个区间 \([l,r]\)，表示将区间 \([l,r]\) 的所有点都覆盖一次，现在定义一个 \(bad\) 点：若 \(i\) 被 \(cnt\) 个区间覆盖
若 \(cnt > k\) 则 \(i\) 这个点是坏的，现在你可以删除一些区间，请问最少删除几个区间，可以使得所有点都不是 \(bad\) 点？
数据范围：
\(1\leq k\leq n\leq2*10^5\)，\(1\leq l \leq r \leq 2*10^5\)
\(Tutorial:\)
首先我们有个贪心的想法，我们按找数轴 \([1,N]\) 遍历过去，每次去看当前这个点被覆盖的次数，看看他要删几个区间
由于我们是小到大遍历点，故遍历到 \(i\) 的时候，说明 \([1,i-1]\) 的所有点都已经通过删除一些区间使得他们不是 \(bad\) 点了
那么我们贪心的想，我们既要减少 \(i\) 的覆盖次数，且我们 \(<i\) 的点都不需要理了，所以我们要尽可能选能覆盖点 \(i\) 且右端点尽可能大的点，这样会尽可能的影响后面的点，使得后面的点覆盖次数减少，从而使我们删除的区间数量尽可能变少。
当 \(n\) 比较小的时候，我们可以直接采用 \(O(n^3)\) 的实习方式实现我们这个思路:
\(O(n^3)\) 的 \(Code:\)
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const int N = 210;
PII seg[N];
vector<int> g[N];
bool st[N];
int cnt[N];
void solve() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
auto &[l, r] = seg[i];
cin >> l >> r;
for (int j = l; j <= r; j++) {
g[j].push_back(i);
cnt[j]++;
}
}
vector<int> ans;
for (int i = 1; i < N; i++) {
if (cnt[i] > k) {
vector<array<int, 3>> cur;
for (auto v : g[i]) {
if (st[v]) continue;
if (seg[v].first <= i && seg[v].second >= i) {
cur.push_back({seg[v].second, seg[v].first, v});
}
}
sort(cur.begin(), cur.end(),[&](array<int, 3> x, array<int, 3> y){
return x[0] > y[0];
});
int up = cnt[i] - k;
for (int j = 0; j < cur.size() && j < up; j++) {
auto [r, l, id] = cur[j];
st[id] = true;
ans.push_back(id);
for (int u = l; u <= r; u++) {
cnt[u]--;
}
}
}
}
cout << ans.size() << '\n';
for(int i = 0; i < ans.size(); i++) {
cout << ans[i] << " \n" [i == ans.size() - 1];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
//cin >> t;
t = 1;
while (t--) {
solve();
}
return 0;
}
当 \(n\) 比较大的时候，我们要考虑如何实现如下两个功能：
- 时刻维护覆盖点 \(i\) 的区间，支持插入删除区间
- 快速的在能覆盖点 \(i\) 的区间里面找到，右端点最大的
我们可以很容易想到用 \(set\) 来维护，我们可以用 \(set\) 维护 \(\{r,id\}\) 表示一个区间的右端点以及其编号
然后，我们遍历到 \(i\) 的时候，要把不能覆盖他的区间删了，以及加入以 \(i\) 为左端点的区间，然后维护和 \(k\) 的关系
\(>k\) 就删除右端点最大的那个
时间复杂度是 \(O(NlogN)\) 的，由于我们每个区间最多只会被加入一次，删除一次
\(O(NlogN)\) 的 \(Code:\)
#include <bits/stdc++.h>
using namespace std;
struct node {
int r, id;
bool operator < (const node& w) const {
if (r != w.r) return r < w.r;
return id < w.id;
}
};
const int N = 2e5 + 10;
vector<node> g[N];
void solve() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int l, r;
cin >> l >> r;
g[l].push_back({r, i});
}
set<node> se;
vector<int> ans;
for (int i = 1; i < N; i++) {
while (se.size() && se.begin()->r < i) {
se.erase(*se.begin());
}
for (auto v : g[i]) {
se.insert(v);
}
while (se.size() > k) {
ans.push_back(se.rbegin()->id);
se.erase(*se.rbegin());
}
}
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " \n" [i == ans.size() - 1];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
//cin >> t;
t = 1;
while (t--) {
solve();
}
return 0;
}
F. Maximum Weight Subset
题意：
给你一棵 \(n\) 个节点的树，每个点有一个权值 \(a_i\)，现在你需要再树里面选一些点集，满足点集里面任意两个点 \(u,v\) 之间
的距离都要 \(>k\)，请问满足条件的所有点集中权值之和最大是多少？
数据范围：
\(1\leq n,k\leq 200\)
\(Tutorial:\)
看到数据范围，以及树上问题，就可以往树形 \(dp\) 想了，由数据范围我们可以推测 \(dp\) 的维数大概是 \(2\) 维左右
由于题目限制任意两个点的距离都要大于 \(k\)，其等价于点集中距离最小的两个点都要 \(>k\) ，考虑到树形 \(dp\) 我们是以一个子树为单位考虑的，且我们需要合并子树是通过根节点合并的，考虑到这些因素，我们可以设 \(dp[i][j]\) 表示在以 \(i\) 为根的子树内
选择点，且所选点距离根节点 \(i\) 的最小距离至少是 \(j\)
现在我们考虑如何进行转移，首先我们分两种情况讨论，对于 \(dfs\) 到节点 \(i\) 我们有两种选择：
- 选根节点，我们易得 \(dp[i][0] = \sum _{v\in son_i}dp[v][k]\)
- 不选根节点，那么对于 \(dp[i][j]\) 我们要从子树里面选一棵子树为\(dp[v][j-1]\)
那么剩余的子树的选取就为：\(dp[v][max(j-1,k-j)]\)
故这类转移的答案就为：\(dp[i][j]=max_{v\in son_i}\{dp[v][j-1]+\sum_{z\in son_i \ \&\& \ z\not = v}dp[z][max(j-1,k-j)]\}\)
这里讨论一下为什么其余子树是 \(max(j-1,k-j)\) 首先由于 \(j-1\) 是最小值，所以其它子树不能低于这个值
同时，我们还要考虑到任意两颗子树直接的距离，对于所选子树的最小值 \(j-1\)，那么其余子树的最小值至少是 \(k-j\)才行
这样两棵子树任取两个点的最小距离就为：\(j-1+k-j+1+1=k+1>k\)，是满足条件的
综上所诉就得到了这个 \(max(j-1,k-j)\)
同时注意转移的细节，可以先记 \(tot=\sum_{v\in son_i}dp[v][max(j-1,k-j)]\)
这样可以使得转移复杂度从 \(O(n^3)\) 变成 \(O(n^2)\) 的
\(Code:\)
#include <bits/stdc++.h>
using namespace std;
const int N = 210;
int a[N];
vector<int> g[N];
int dp[N][N];
int n, k;
void dfs(int u, int fa) {
dp[u][0] = a[u];
for (auto v : g[u]) {
if (v == fa) continue;
dfs(v, u);
dp[u][0] += dp[v][k];
}
for (int j = 1; j <= n; j++) {
int tot = 0;
for (auto v : g[u]) {
if (v == fa) continue;
tot += dp[v][max(j - 1, k - j)];
}
for (auto v : g[u]) {
if (v == fa) continue;
dp[u][j] = max(dp[u][j], dp[v][j - 1] + tot - dp[v][max(j - 1, k - j)]);
}
}
for (int i = n; i >= 0; i--) {
dp[u][i] = max(dp[u][i], dp[u][i + 1]);
}
}
void solve() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, -1);
int ans = 0;
for (int i = 0; i <= n; i++) {
ans = max(ans, dp[1][i]);
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
//cin >> t;
t = 1;
while (t--) {
solve();
}
return 0;
}
浙公网安备 33010602011771号