题意:
题面有点问题,按照人类正常的理解来就好啦。
思路:
可以想到维护每个位置的一个斜率,模拟的话就是从第一个位置开始向后选,当某个位置斜率大于当前位置的时候,答案加一,并且将斜率更新为这个最大值。
有修改操作,复杂度显然过不去,考虑用线段树维护。
线段树维护的话,修改很好写,按照正常的来就好,主要在于如何
p
u
s
h
u
p
pushup
pushup。
首先我们维护的信息需要当前区间的斜率最大值
m
x
mx
mx,当前区间要求的长度
l
e
n
len
len。那么
p
u
s
h
u
p
pushup
pushup的时候
m
x
mx
mx直接取两个子树的
m
a
x
max
max即可,而
l
e
n
len
len就没那么简单了。
考虑如何更新
l
e
n
len
len,由于是从左往右看的,那么左边的
l
e
n
len
len所包含的位置是必选的,那么先让
t
r
[
u
]
.
l
e
n
=
t
r
[
L
]
.
l
e
n
tr[u].len=tr[L].len
tr[u].len=tr[L].len, 选完左边之后,左边的最大值一定被选到了,那么就用最大值来切右边,即定义一个
c
a
l
c
(
u
,
k
)
calc(u,k)
calc(u,k)的函数,返回的是当前区间
u
u
u斜率大于
k
k
k的条件下从左到右能看到的最多的房屋。那么在
c
a
l
c
calc
calc函数中如果到了叶子,就直接返回
m
x
>
k
mx>k
mx>k即可,否则分以下两种情况:
(
1
)
(1)
(1)
t
r
[
L
]
.
m
x
<
=
k
tr[L].mx<=k
tr[L].mx<=k,那么此时左区间都被砍掉了,递归左区间,返回
c
a
l
c
(
R
,
k
)
calc(R,k)
calc(R,k)即可。
(
2
)
(2)
(2)
t
r
[
L
]
.
m
x
>
k
tr[L].mx>k
tr[L].mx>k,此时左区间没有全部被砍掉,那么说明左区间是有一部分楼房能被看到,那么显然我们需要递归左区间也需要递归右区间,即
c
a
l
c
(
L
,
k
)
+
c
a
l
c
(
R
,
t
r
[
L
]
.
m
x
)
calc(L,k)+calc(R,tr[L].mx)
calc(L,k)+calc(R,tr[L].mx),但是这样复杂度会剧增,考虑如何优化呢?显然我们左区间是一定要递归的,如何快速算出来右区间的长度呢?注意到此时左区间的最大值是一定被选到了,当前整个区间的长度就是由
t
r
[
L
]
.
l
e
n
+
c
a
l
c
(
R
,
t
r
[
L
]
.
m
x
)
tr[L].len+calc(R,tr[L].mx)
tr[L].len+calc(R,tr[L].mx)得到的,那么
c
a
l
c
(
R
,
t
r
[
L
]
,
m
x
)
=
t
r
[
u
]
.
l
e
n
−
t
r
[
L
]
.
l
e
n
calc(R,tr[L],mx)=tr[u].len-tr[L].len
calc(R,tr[L],mx)=tr[u].len−tr[L].len,这样
c
a
l
c
calc
calc函数复杂度是稳定的
l
o
g
n
logn
logn的了。
最终答案就是
t
r
[
1
]
.
l
e
n
tr[1].len
tr[1].len。
总体复杂度 n ( l o g n ) 2 n(logn)^2 n(logn)2
// Problem: P4198 楼房重建
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P4198
// Memory Limit: 125 MB
// Time Limit: 1000 ms
//
// Powered by CP Editor (https://cpeditor.org)
//#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")
//#pragma GCC optimize(2)
#include<cstdio>
#include<iostream>
#include<string>
#include<cstring>
#include<map>
#include<cmath>
#include<cctype>
#include<vector>
#include<set>
#include<queue>
#include<algorithm>
#include<sstream>
#include<ctime>
#include<cstdlib>
#define X first
#define Y second
#define L (u<<1)
#define R (u<<1|1)
#define pb push_back
#define mk make_pair
#define Mid (tr[u].l+tr[u].r>>1)
#define Len(u) (tr[u].r-tr[u].l+1)
#define random(a,b) ((a)+rand()%((b)-(a)+1))
#define db puts("---")
using namespace std;
//void rd_cre() { freopen("d://dp//data.txt","w",stdout); srand(time(NULL)); }
//void rd_ac() { freopen("d://dp//data.txt","r",stdin); freopen("d://dp//AC.txt","w",stdout); }
//void rd_wa() { freopen("d://dp//data.txt","r",stdin); freopen("d://dp//WA.txt","w",stdout); }
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int,int> PII;
const int N=1000010,mod=1e9+7,INF=0x3f3f3f3f;
const double eps=1e-6;
int n,m;
struct Node {
int l,r;
int len;
double mx;
}tr[N<<2];
void pushup(int u) {
tr[u].mx=max(tr[L].mx,tr[R].mx);
}
void build(int u,int l,int r) {
tr[u]={l,r};
if(l==r) return;
build(L,l,Mid); build(R,Mid+1,r);
}
int calc(int u,double k) {
if(tr[u].mx<=k) return 0;
if(tr[u].l==tr[u].r) return tr[u].mx>k;
if(tr[L].mx<=k) return calc(R,k);
else return tr[u].len-tr[L].len+calc(L,k);
}
void change(int u,int l,int r,double k) {
if(tr[u].l>=l&&tr[u].r<=r) {
tr[u].mx=k;
tr[u].len=1;
return;
}
if(l<=Mid) change(L,l,r,k);
else change(R,l,r,k);
pushup(u);
tr[u].len=tr[L].len+calc(R,tr[L].mx);
}
int main()
{
// ios::sync_with_stdio(false);
// cin.tie(0);
scanf("%d%d",&n,&m);
build(1,1,n);
for(int i=1;i<=m;i++) {
int x,y; scanf("%d%d",&x,&y);
double k=1.0*y/x;
change(1,x,x,k);
printf("%d\n",tr[1].len);
}
return 0;
}
/*
*/