NC22593 签到题
题目
题目描述
恭喜你找到了本场比赛的签到题！
为了让大家都有抽奖的机会，只需要复制粘贴以下代码（并且稍微填下空）即可 AC：
（我超良心的）
#include <algorithm>
#include <iostream>
#include <cstring>
#include <climits>
#include <cstdio>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#define fi first
#define lc (x<<1)
#define se second
#define U unsigned
#define rc (x<<1|1)
#define Re register
#define LL long long
#define MP std::make_pair
#define CLR(i,a) memset(i,a,sizeof(i))
#define FOR(i,a,b) for(Re int i = a;i <= b;++i)
#define ROF(i,a,b) for(Re int i = a;i >= b;--i)
#define SFOR(i,a,b,c) for(Re int i = a;i <= b;i+=c)
#define SROF(i,a,b,c) for(Re int i = a;i >= b;i-=c)
#define DEBUG(x) std::cerr << #x << '=' << x << std::endl
const int MAXN = 1000000+5;
int N,maxL;
std::set<std::pair<int,int> > L;
inline int calc(){
// 返回 set 中所有线段的并长度。(每个 pair 表示一个线段[first,second]
}
int main(){
scanf("%d%d",&N,&maxL);
while(N--){
int opt,x,y;
scanf("%d%d%d",&opt,&x,&y);
if(opt == 1){
if(L.find(MP(x,y)) != L.end()) continue;
L.insert(MP(x,y));
}
if(opt == 2){
if(L.find(MP(x,y)) == L.end()) continue;
L.erase(MP(x,y));
}
if(opt == 3){
printf("%d\n",calc());
}
}
return 0;
}
输入描述
第一行两个整数 N,L，意义如代码所述。
接下来 N 行，每行三个整数 opt,l,r，意义如代码所述。
输出描述
对于每一组 opt=3 的询问输出一个答案。
示例1
输入
6 13
1 1 2
1 4 5
1 4 7
1 6 9
1 12 13
3 3 3
输出
10
说明
我们依次加入线段 \([1,2],[4,5],[4,7],[6,9],[12,13]\) ， 它们的并集长度为 10.
备注
\(N \leq 10^5,L \leq 10^5 ,0 \leq l \leq r \leq L\) ，保证数据随机生成。
题解
方法一
知识点：线段树，扫描线。
长度并问题，可以用扫描线的区间覆盖线段树解决。
需要注意的是，题目的长度是区间点的个数，为了便于区间覆盖线段树实现，可以先将每个点映射为一个区间，因此可以有映射 0(1,2),1(2,3),...,L(L+1,L+2) ，表示用区间 \([1,2],[2,3],\cdots ,[L+1,L+2]\) 表示点 \(0,1,\cdots,L\) 。
设 \(dot\) 为映射后的端点集，即 \(\{ 1,2, \cdots ,L+2 \}\) 。注意，线段树维护的是 \(dot\) 点构成的区间，例如 \(1\) 号区间对应 \(dot\) 的 \([1,2]\) ，即原题的点 \(0\) 代表的区间。
区间信息需要维护编号左右端点 \(l,r\) 、被完整覆盖次数 \(cnt\) 、区间覆盖长度 \(len\) 。分三类讨论：
- 区间被完整覆盖，则 \(len\) 为整个区间实际长度。
- 否则，若区间是一个点，则覆盖长度为 \(0\) 。
- 否则， \(len\) 由子区间转移。
push_up 函数为：
void push_up(int rt) {
if (node[rt].cnt) node[rt].len = dot[node[rt].r + 1] - dot[node[rt].l];
else if (node[rt].l == node[rt].r) node[rt].len = 0;
else node[rt].len = node[rt << 1].len + node[rt << 1 | 1].len;
}
区间修改需要维护新增线段个数 \(cnt\) 。显然，对相应区间的完整覆盖次数加上 \(cnt\) ，然后用向上转移函数更新答案即可。区间修改函数为：
node[rt].cnt += cnt, push_up(rt);
可以发现，线段树区间的长度 \(r-l+1\) 等于实际长度 \(dot_{r+1} - dot_{l}\) 等于原题 \([l,r]\) 表示的长度。因此实际上， \(dot\) 集合在这道题里是不需要显示存储的，可以直接用线段树区间长度计算。
注意，若点间距是不等的，那么 \(dot\) 集合是必须的，通常需要离散化后，方便线段树实现。这里，其实为了展示扫描线所使用的线段树，就没有直接用线段树区间长度代替实际长度计算。
时间复杂度 \(O((n+L) \log L)\)
空间复杂度 \(O(L)\)
方法二
知识点：线段树。
这道题同样也可以通过记录一个区间没有被覆盖到的单位区间个数，从而计算一整个区间被覆盖到的区间长度。
区间信息需要维护长度 \(len\) 、最小覆盖数 \(cover\) 、最小覆盖的单位区间个数 \(cnt\) 。 push_up 函数为：
friend T operator+(const T &a, const T &b) {
int len = a.len + b.len;
int cover = min(a.cover, b.cover);
int cnt = (a.cover == cover ? a.cnt : 0) + (b.cover == cover ? b.cnt : 0);
return {
len,
cover,
cnt,
};
}
区间修改需要维护新增线段个数 \(add\) 。显然只需要对 \(cover\) 加 \(add\) 即可。区间修改函数为：
T operator()(const T &x) {
return{
x.len,
x.cover + add,
x.cnt
};
}
区间修改有结合律，可以设置懒标记。 push_down 函数（此题只询问 \([1,n]\) ，所以可以不写这个函数）：
F operator()(const F &g) { return { g.add + add }; }
时间复杂度 \(O((n+L) \log L)\)
空间复杂度 \(O(L)\)
代码
方法一
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template<class T>
class Scanline {
struct Segment {
int l;
int r;
int cnt;
T len;
};
int n;
vector<T> dot;
vector<Segment> node;
void push_up(int rt) {
if (node[rt].cnt) node[rt].len = dot[node[rt].r + 1] - dot[node[rt].l];
else if (node[rt].l == node[rt].r) node[rt].len = 0;
else node[rt].len = node[rt << 1].len + node[rt << 1 | 1].len;
}
void update(int rt, int l, int r, int x, int y, int cnt) {
if (r < x || y < l) return;
if (x <= l && r <= y) return node[rt].cnt += cnt, push_up(rt);
int mid = l + r >> 1;
update(rt << 1, l, mid, x, y, cnt);
update(rt << 1 | 1, mid + 1, r, x, y, cnt);
push_up(rt);
}
public:
Scanline() {}
Scanline(const vector<T> &_dot) { init(_dot); }
void init(const vector<T> &_dot) {
assert(_dot.size() - 1 >= 1);
n = _dot.size() - 2;
dot = _dot;
node.assign(n << 2, { 0,0,0,0 });
function<void(int, int, int)> build = [&](int rt, int l, int r) {
node[rt] = { l,r,0,0 };
if (l == r) return;
int mid = l + r >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
};
build(1, 1, n);
}
void update(int x, int y, int cnt) { update(1, 1, n, x, y, cnt); }
Segment query() { return node[1]; }
};
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, L;
cin >> n >> L;
vector<int> dot(L + 3); //* 0(1,2),1(2,3),...,L(L+1,L+2)
iota(dot.begin(), dot.end(), 0);
Scanline<int> sl(dot);//* 线段长度，端点集
set<pair<int, int>> st;
for (int i = 1;i <= n;i++) {
int op, l, r;
cin >> op >> l >> r;
l++, r++;
if (op == 1) {
if (st.find({ l, r }) != st.end())
continue;
st.insert({ l, r });
sl.update(l, r, { 1 });
}
if (op == 2) {
if (st.find({ l, r }) == st.end())
continue;
st.erase({ l,r });
sl.update(l, r, { -1 });
}
if (op == 3) {
cout << sl.query().len << '\n';
}
}
return 0;
}
方法二
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct T {
int len; //区间长度
int cover; //最小覆盖数
int cnt; //最小覆盖的单位区间个数
static T e() { return { 0,(int)2e9,0 }; }
friend T operator+(const T &a, const T &b) {
int len = a.len + b.len;
int cover = min(a.cover, b.cover);
int cnt = (a.cover == cover ? a.cnt : 0) + (b.cover == cover ? b.cnt : 0);
return {
len,
cover,
cnt,
};
}
};
struct F {
int add;
static F e() { return { 0 }; }
T operator()(const T &x) {
return{
x.len,
x.cover + add,
x.cnt
};
}
F operator()(const F &g) { return { g.add + add }; }
};
template<class T, class F>
class SegmentTreeLazy {
int n;
vector<T> node;
vector<F> lazy;
void push_down(int rt) {
node[rt << 1] = lazy[rt](node[rt << 1]);
lazy[rt << 1] = lazy[rt](lazy[rt << 1]);
node[rt << 1 | 1] = lazy[rt](node[rt << 1 | 1]);
lazy[rt << 1 | 1] = lazy[rt](lazy[rt << 1 | 1]);
lazy[rt] = F::e();
}
void update(int rt, int l, int r, int x, int y, F f) {
if (r < x || y < l) return;
if (x <= l && r <= y) return node[rt] = f(node[rt]), lazy[rt] = f(lazy[rt]), void();
push_down(rt);
int mid = l + r >> 1;
update(rt << 1, l, mid, x, y, f);
update(rt << 1 | 1, mid + 1, r, x, y, f);
node[rt] = node[rt << 1] + node[rt << 1 | 1];
}
T query(int rt, int l, int r, int x, int y) {
if (r < x || y < l) return T::e();
if (x <= l && r <= y) return node[rt];
push_down(rt);
int mid = l + r >> 1;
return query(rt << 1, l, mid, x, y) + query(rt << 1 | 1, mid + 1, r, x, y);
}
public:
SegmentTreeLazy(int _n = 0) { init(_n); }
SegmentTreeLazy(int _n, const vector<T> &src) { init(_n, src); }
void init(int _n) {
n = _n;
node.assign(n << 2, T::e());
lazy.assign(n << 2, F::e());
}
void init(int _n, const vector<T> &src) {
init(_n);
function<void(int, int, int)> build = [&](int rt, int l, int r) {
if (l == r) return node[rt] = src[l], void();
int mid = l + r >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
node[rt] = node[rt << 1] + node[rt << 1 | 1];
};
build(1, 1, n);
}
void update(int x, int y, F f) { update(1, 1, n, x, y, f); }
T query(int x, int y) { return query(1, 1, n, x, y); }
};
int main() {
std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, L;
cin >> n >> L;
SegmentTreeLazy<T, F> sgt(L + 1, vector<T>(L + 2, { 1,0,1 }));
set<pair<int, int>> st;
for (int i = 1;i <= n;i++) {
int op, l, r;
cin >> op >> l >> r;
l++, r++;
if (op == 1) {
if (st.find({ l, r }) != st.end())
continue;
st.insert({ l, r });
sgt.update(l, r, { 1 });
}
if (op == 2) {
if (st.find({ l, r }) == st.end())
continue;
st.erase({ l,r });
sgt.update(l, r, { -1 });
}
if (op == 3) {
auto [len, cover, cnt] = sgt.query(1, L + 1);
cout << (cover ? len : len - cnt) << '\n';
}
}
return 0;
}
本文来自博客园，作者：空白菌，转载请注明原文链接：https://www.cnblogs.com/BlankYang/p/17358406.html
